update

Author: jinzhongjia

course/basic/advanced_type/array.md

@@ -24,6 +24,12 @@ outline: deep
 
 关于[越界问题](https://ziglang.org/documentation/master/#Index-out-of-Bounds)，zig 在编译期和运行时均有完整的越界保护和完善的堆栈错误跟踪。
 
+### 解构数组
+
+我们在变量声明的章节提到了，数组可以结构，再来回忆一下：
+
+<<<@/code/release/array.zig#deconstruct
+
 ### 多维数组
 
 多维数组（矩阵）实际上就是嵌套数组，我们很容易就可以创建一个多维数组出来：

course/basic/advanced_type/vector.md

@@ -6,6 +6,8 @@ outline: deep
 
 > 向量（Vector）为我们提供了并行操纵一组同类型（布尔、整型、浮点、指针）的值的方法，它尽可能使用 `SIMD` 指令。
 
+向量类型使用内置函数 [@Vector](https://ziglang.org/documentation/master/#Vector) 创建
+
 ## 基本使用
 
 向量支持与底层基本类型相同的内置运算符。这些操作是按元素执行，并返回与输入向量长度相同的向量，包括：
@@ -30,6 +32,12 @@ Zig 支持任何已知的最大 2^32-1 向量长度。请注意，过长的向
 
 :::
 
+## 解构向量
+
+和数组一样，向量也可以被解构：
+
+<<<@/code/release/vector.zig#deconstruct
+
 ## `@splat`
 
 `@splat(scalar: anytype) anytype`

course/basic/define-variable.md

@@ -69,6 +69,12 @@ zig 使用 `const` 作为关键字来声明常量，它无法再被更改，只
 
 <<<@/code/release/define_variable.zig#deconstruct
 
+解构表达式只能出现在块内（不在容器范围内），赋值的左侧必须由逗号分隔的列表组成，其中每个元素可以是左值（例如`var`）或变量声明：
+
+<<<@/code/release/define_variable.zig#deconstruct_2
+
+解构可以以 `comptime` 关键字作为前缀，在这种情况下，整个解构表达式在 `comptime` 处求值。所有声明的 `var` 都将是 `comptime var`，并且所有表达式（左值和右值）都在 `comptime` 处求值。
+
 ## 块
 
 块（block）用于限制变量声明的范围，例如以下代码是非法的：

course/code/14/array.zig

@@ -21,6 +21,28 @@ const CreateArray = struct {
     // #endregion create_array
 };
 
+const Deconstruct = struct {
+    // #region deconstruct
+    const print = @import("std").debug.print;
+
+    fn swizzleRgbaToBgra(rgba: [4]u8) [4]u8 {
+        // 解构
+        const r, const g, const b, const a = rgba;
+        return .{ b, g, r, a };
+    }
+
+    pub fn main() void {
+        const pos = [_]i32{ 1, 2 };
+        // 解构
+        const x, const y = pos;
+        print("x = {}, y = {}\n", .{ x, y });
+
+        const orange: [4]u8 = .{ 255, 165, 0, 255 };
+        print("{any}\n", .{swizzleRgbaToBgra(orange)});
+    }
+    // #endregion deconstruct
+};
+
 const Matrix = struct {
     // #region matrix
     const print = @import("std").debug.print;

course/code/14/define_variable.zig

@@ -137,13 +137,53 @@ const Block = struct {
 const Deconstruct = struct {
     fn main() void {
         // #region deconstruct
+        const print = @import("std").debug.print;
+        var x: u32 = undefined;
+        var y: u32 = undefined;
         var z: u32 = undefined;
-        // var z: u32 = undefined;
-        const x, var y, z = [3]u32{ 1, 2, 3 };
-        y += 10;
-        // x 是 1，y 是 2，z 是 3
+        // 元组
+        const tuple = .{ 1, 2, 3 };
+        // 解构元组
+        x, y, z = tuple;
+
+        print("tuple: x = {}, y = {}, z = {}\n", .{ x, y, z });
+        // 数组
+        const array = [_]u32{ 4, 5, 6 };
+        // 解构数组
+        x, y, z = array;
+
+        print("array: x = {}, y = {}, z = {}\n", .{ x, y, z });
+        // 向量定义
+        const vector: @Vector(3, u32) = .{ 7, 8, 9 };
+        // 解构向量
+        x, y, z = vector;
+
+        print("vector: x = {}, y = {}, z = {}\n", .{ x, y, z });
         // #endregion deconstruct
-        _ = x;
+
+    }
+};
+
+const Deconstruct_2 = struct {
+    pub fn main() !void {
+        // #region deconstruct_2
+        const print = @import("std").debug.print;
+        var x: u32 = undefined;
+
+        const tuple = .{ 1, 2, 3 };
+
+        x, var y: u32, const z = tuple;
+
+        print("x = {}, y = {}, z = {}\n", .{ x, y, z });
+
+        // y 可变
+        y = 100;
+
+        // 可以用 _ 丢弃不想要的值
+        _, x, _ = tuple;
+
+        print("x = {}", .{x});
+        // #endregion deconstruct_2
     }
 };
 

course/code/14/vector.zig

@@ -49,6 +49,24 @@ const Splat = struct {
     }
 };
 
+const Deconstruct = struct {
+    // #region deconstruct
+    const print = @import("std").debug.print;
+
+    pub fn unpack(x: @Vector(4, f32), y: @Vector(4, f32)) @Vector(4, f32) {
+        const a, const c, _, _ = x;
+        const b, const d, _, _ = y;
+        return .{ a, b, c, d };
+    }
+
+    pub fn main() void {
+        const x: @Vector(4, f32) = .{ 1.0, 2.0, 3.0, 4.0 };
+        const y: @Vector(4, f32) = .{ 5.0, 6.0, 7.0, 8.0 };
+        print("{}", .{unpack(x, y)});
+    }
+    // #endregion deconstruct
+};
+
 const Reduce = struct {
     const std = @import("std");
     const print = std.debug.print;