JavaScript 自 ES6 之后便支持数组和对象的解构(Destructuring),使我们可以快速地将数组的元素值和对象中的属性值指派给变量或是常数来保存。

直接举个例子来说明基本的数组解构和对象解构的语法:

const array = [1, "2"];
const object = {
    f1: 3,
    f2: "4",
};

const [a, b] = array;
const { f1: c, f2: d } = object;

console.log(a);
console.log(b);
console.log(c);
console.log(d);

以上程序的输出结果如下:

1
2
3
4

将原本应该要声明常数名称或是变量名称的地方,直接改用中括号 [] 语法来表示数组结构,或用大括号 {} 语法来表示对象结构,并在结构中使用自订的名称来代替要解构出来的值。我们就不需要写出如下麻烦的程序啦!

const array = [1, "2"];
const object = {
    f1: 3,
    f2: "4",
};

const a = array[0];
const b = array[1];
const c = object.f1;
const d = object.f2;

console.log(a);
console.log(b);
console.log(c);
console.log(d);

当解构的对象是对象时,我们也可以直接使用属性名称来当作变量或常数的名称。举例来说:

let { f1: c, f2: d } = {
    f1: 1,
    f2: "2",
};

以上程序可以写为:

let { f1, f2 } = {
    f1: 1,
    f2: "2",
};

如此一来就声明了 f1 和 f2 这两个变量,它们的值分别是数值 1 和字符串 2。

在 TypeScript 中,因为会做类型检查,所以我们在解构对象时,必须要把该类型的所有属性都写出来。像是以下程序就会编译错误:

const { f1 } = {
    f1: 1,
    f2: "2",
};

这个程序编译错误的原因,其实就和以下程序编译错误的原因是类似的:

const o: {f1: number} = {
    f1: 1,
    f2: "2",
};

应该是 TypeScript 怕开发者在首次解构大括号对象的类型时,不小心没写到对象中有用到的属性才做的限制。

为了能够在解构时只取得我们要的对象属性,要将程序改成以下这样才能成功编译:

const o = {
    f1: 1,
    f2: "2",
};

const { f1 } = o;

然而解构数组不会有上述的限制。例如:

const a: [number] = [1, "2"];

以上程序会编译失败,但以下程序可以编译成功:

const [n] = [1, "2"];

嵌套解构

若对象属性中还有其它对象,而我们想取得对象中的对象的属性值时,也是可以使用解构语法。例如:

const o = {
    f1: 3,
    f2: "4",
    f3: { f4: true },
};

const { f3: { f4 } } = o;

console.log(f4);

参数解构

函数的参数名称也是可以套用这样的解构语法。例如:

const o = {
    f1: 3,
    f2: "4",
    f3: { f4: true },
};

const isF4True = ({ f3: { f4 } }: { f3: { f4: boolean } }) => {
    return f4;
};

console.log(isF4True(o));

剩余属性解构

还记得在先前的章节中提到的 ... 蔓延语法吗?我们也可以在解构语法中的最后一个名称的前方加上 ...,但这里就不是原先蔓延语法的功能(将数组的元素拆成参数)了,而是用来表示所有未被明确写出来的属性或元素。

先用数组来举例会比较容易一点,如下:

const [n, s, ...remains] = [1, "2", true, Symbol(10)];

console.log(n);
console.log(s);
console.log(remains);

以上程序的输出结果如下:

1
2
[ true, Symbol(10) ]
const o = {
    f1: 3,
    f2: "4",
    f3: {
        a: 6,
        b: 7,
        c: 8,
    },
    f4: { f5: true },
};

const { f3: { b, ...remains2 }, ...remains } = o;

console.log(b);
console.log(remains);
console.log(remains2);

以上程序的输出结果如下:

7
{ f1: 3, f2: '4', f4: { f5: true } }
{ a: 6, c: 8 }

解构对象时,... 语法只能用在属性键值上,不能用在属性值上。例如以下就是个明显错误的程序:

const o = {
    f1: 3,
    f2: '4',
    f3: false,
};

const {f1: n, f2: ...remains} = o;

数组的直接解构

数组并不一定要在声明名称时才能被解构,在撰写一般指派叙述的时候也可以使用解构语法。例如:

let n, s;

[n, s] = [1, "2", false];

console.log(n);
console.log(s);

以上程序会输出:

1
2

解构时的默认值

有时候我们解构对象出来的属性值可能会是 undefined,如果不想要得到 undefined 的话,可以利用 = 替我们声明出来的名称加上一个默认值。这个默认值可以是任意类型的值。

例如:

const o: { name: string, age: number, toString: () => string, "student-number"?: string} = {
    name: "David",
    age: 18,
    toString: () => `${o.age}: ${o.name}`,
};

const { "student-number": studentNumber = "unknown" } = o;

console.log(studentNumber);

以上程序会输出:

unknown

数组解构时也可以设置默认值,例如:

const [n, s, o = {}] = [1, "2"];

总结

在这个章节中,我们学会了如何在 TypeScript 中,对数组和对象应用解构语法来简化程序。在下一个章节要来介绍「try-catch」。

下一章:try-catch 错误处理。