现代 JavaScript 教程之解构赋值:数组与对象的解构语法深度指南
现代 JavaScript 教程之解构赋值:数组与对象的解构语法深度指南
解构赋值(Destructuring Assignment)是 JavaScript 中最常用的语法之一,它允许把数组元素或对象属性"解包"到一组独立变量中,从而大幅简化取值代码。本文以本项目 1-js/05-data-types/10-destructuring-assignment/article.md 为核心,完整讲解数组解构、对象解构、剩余模式(rest)、默认值、嵌套解构与智能函数参数等全部要点,并辅以仓库内的配套练习与测试用例作深度佐证。学完本文,你将能够用解构语法写出更简洁、更易读、更能应对复杂函数签名的 JavaScript 代码。
为什么需要解构赋值
JavaScript 中最常用的两种数据结构是 Object 和 Array:
- 对象允许我们按**键(key)**存储数据,创建单个实体;
- 数组允许我们把数据项收集进有序列表。
但当我们把这些结构传给函数时,往往并不需要其中的全部内容——函数可能只需要某些元素或某些属性。此时逐一用 arr[0]、obj.prop 去取值既啰嗦又容易出错。
解构赋值 就是一种特殊语法,它让我们可以把数组或对象"解包"成一组变量,使用起来更加方便。它尤其适合那些参数很多、带有默认值、结构复杂的函数场景,下文会逐步展开。
数组解构
数组解构是最直观的入门形式。下面这个例子把数组的两个元素分别赋给两个变量:
// 我们有一个包含名和姓的数组
let arr = ["John", "Smith"];
// 解构赋值
// 将 firstName = arr[0]
// 将 surname = arr[1]
let [firstName, surname] = arr;
alert(firstName); // John
alert(surname); // Smith
这样一来,我们就可以直接用变量名工作,而不再依赖数组下标。
解构与 split 等返回数组的方法搭配使用效果极佳:
let [firstName, surname] = "John Smith".split(' ');
alert(firstName); // John
alert(surname); // Smith
"解构"不等于"破坏"
解构赋值名为 "destructuring",是因为它把数组复制进变量,从而"解构"了结构;但数组本身并不会被修改。它只是下面这种写法的更短版本:
// let [firstName, surname] = arr;
let firstName = arr[0];
let surname = arr[1];
用逗号忽略元素
不需要的数组元素可以通过多加一个逗号来跳过:
// 第二个元素不需要
let [firstName, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
alert( title ); // Consul
在上面的代码中,数组的第二个元素被跳过,第三个元素赋给了 title,其余元素因为没有对应变量而被一并忽略。
右侧可以是任意可迭代对象
解构并不局限于数组——任何可迭代对象都可以作为右侧值:
let [a, b, c] = "abc"; // ["a", "b", "c"]
let [one, two, three] = new Set([1, 2, 3]);
之所以可行,是因为解构赋值在内部就是通过对右侧值进行迭代来工作的。它本质上是"对 = 右侧的值执行 for..of 循环并依次赋值"的语法糖。
左侧可以是任意"可赋值"目标
左侧也不一定非得是变量,任何"可赋值"的目标都可以,比如对象属性:
let user = {};
[user.name, user.surname] = "John Smith".split(' ');
alert(user.name); // John
alert(user.surname); // Smith
配合 .entries() 循环遍历键值对
在上一章 Object.keys, values, entries 中我们介绍过 Object.entries(obj) 方法。它返回形如 [[key, value], ...] 的"真实数组",因此天然适合与解构配合,在循环中遍历对象的键与值:
let user = {
name: "John",
age: 30
};
// 遍历键值对
for (let [key, value] of Object.entries(user)) {
alert(`${key}:${value}`); // 先是 name:John,再是 age:30
}
对于 Map,代码更简单,因为 Map 本身就是可迭代的,并且迭代出的正是 [key, value] 对:
let user = new Map();
user.set("name", "John");
user.set("age", "30");
// Map 按 [key, value] 对迭代,非常适合解构
for (let [key, value] of user) {
alert(`${key}:${value}`); // 先是 name:John,再是 age:30
}
这种"Object.entries / Map 迭代 + 解构"的组合,正是仓库练习 6-max-salary 的核心思路,后文会结合源码与测试展开。
交换变量的经典技巧
利用解构赋值可以写出一个广为流传的变量交换技巧:
let guest = "Jane";
let admin = "Pete";
// 交换值:让 guest=Pete, admin=Jane
[guest, admin] = [admin, guest];
alert(`${guest} ${admin}`); // Pete Jane(成功交换!)
这里我们创建了一个包含两个变量的临时数组,并立刻按交换后的顺序对它进行解构。这种技巧可以同时交换两个以上的变量。
剩余模式 '...'(rest)
一般情况下,如果数组比左侧的变量列表更长,多出的元素会被直接忽略:
let [name1, name2] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
alert(name1); // Julius
alert(name2); // Caesar
// 其余元素没有被赋值给任何变量
如果想把后面所有剩余元素都收集起来,可以用三个点 "..." 再加一个参数:
let [name1, name2, ...rest] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
// rest 是一个数组,包含从第 3 个开始的元素
alert(rest[0]); // Consul
alert(rest[1]); // of the Roman Republic
alert(rest.length); // 2
rest 的值就是剩余数组元素组成的数组。这里的变量名可以任意起,只要保证前面有 ... 并且位于解构赋值的最后即可:
let [name1, name2, ...titles] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];
// 现在 titles = ["Consul", "of the Roman Republic"]
默认值
如果数组比左侧变量列表更短,不会报错,缺失的值会被视为 undefined:
let [firstName, surname] = [];
alert(firstName); // undefined
alert(surname); // undefined
如果希望用"默认值"填补缺失项,可以使用 = 指定:
// 默认值
let [name = "Guest", surname = "Anonymous"] = ["Julius"];
alert(name); // Julius(来自数组)
alert(surname); // Anonymous(使用了默认值)
默认值可以是更复杂的表达式,甚至是函数调用,而且只有在值缺失时才会被求值。例如下面的代码用 prompt 作为两个变量的默认值:
// 只会为 surname 运行 prompt
let [name = prompt('name?'), surname = prompt('surname?')] = ["Julius"];
alert(name); // Julius(来自数组)
alert(surname); // prompt 得到什么就是什么
请注意:prompt 只会为缺失的那个值(surname)运行。
对象解构
解构赋值同样适用于对象。基本语法为:
let {var1, var2} = {var1:…, var2:…}
右侧应是一个现成的对象,我们希望把它拆分成多个变量;左侧是一个对象式的"模式",用于对应右侧的属性。最简单的情形就是 {...} 里直接列出一组变量名:
let options = {
title: "Menu",
width: 100,
height: 200
};
let {title, width, height} = options;
alert(title); // Menu
alert(width); // 100
alert(height); // 200
属性 options.title、options.width、options.height 被依次赋给对应变量。与数组不同,对象的解构不依赖顺序:
// 改变了 let {...} 中的顺序
let {height, width, title} = { title: "Menu", height: 200, width: 100 }
左侧的模式可以更复杂,用于指定属性与变量之间的映射关系。
属性重命名:冒号映射
如果想给目标变量起不同的名字(例如把 options.width 赋给变量 w),可以通过冒号来指定:
let options = {
title: "Menu",
width: 100,
height: 200
};
// { 源属性: 目标变量 }
let {width: w, height: h, title} = options;
// width -> w
// height -> h
// title -> title
alert(title); // Menu
alert(w); // 100
alert(h); // 200
冒号的含义是"什么: 去哪"。上面的例子中,属性 width 进入 w,属性 height 进入 h,而 title 仍赋给同名变量。
缺失属性的默认值
对于可能缺失的属性,可以用 "=" 设置默认值:
let options = {
title: "Menu"
};
let {width = 100, height = 200, title} = options;
alert(title); // Menu
alert(width); // 100
alert(height); // 200
和数组、函数参数一样,默认值可以是任意表达式甚至函数调用,只在属性缺失时求值。下面的代码 prompt 只会询问 width,不会询问 title:
let options = {
title: "Menu"
};
let {width = prompt("width?"), title = prompt("title?")} = options;
alert(title); // Menu
alert(width); // (prompt 的结果)
冒号与等号结合
冒号(重命名)与等号(默认值)还可以组合使用:
let options = {
title: "Menu"
};
let {width: w = 100, height: h = 200, title} = options;
alert(title); // Menu
alert(w); // 100
alert(h); // 200
这个"重命名 + 默认值"的组合正是仓库练习 1-destruct-user 的考察点,后文会给出官方解答。
只提取需要的属性
面对属性很多的复杂对象,可以只提取我们需要的部分:
let options = {
title: "Menu",
width: 100,
height: 200
};
// 只把 title 提取为变量
let { title } = options;
alert(title); // Menu
对象的剩余模式 "..."
如果对象属性比我们的变量多,可以先取一部分,再把"剩余"整体赋给某个对象吗?可以,使用与数组相同的 rest 模式。它在部分旧浏览器(如 IE)中不受支持(需要 Babel 之类的工具做 polyfill),但在现代浏览器中均可正常工作:
let options = {
title: "Menu",
height: 200,
width: 100
};
// title = 名为 title 的属性
// rest = 包含其余属性的对象
let {title, ...rest} = options;
// 现在 title="Menu", rest={height: 200, width: 100}
alert(rest.height); // 200
alert(rest.width); // 100
没有 let 时的陷阱
上面的例子都是直接在赋值中声明变量:let {…} = {…}。当然也可以使用已有变量而不写 let,但这里有一个陷阱——下面的代码会报错:
let title, width, height;
// 这一行出错
{title, width, height} = {title: "Menu", width: 200, height: 100};
问题在于:JavaScript 会把主代码流中(不在其他表达式内部)的 {...} 视为代码块。这种代码块可以用来分组语句:
{
// 一个代码块
let message = "Hello";
// ...
alert( message );
}
所以上面的例子被 JavaScript 当成了代码块,自然就报错了——我们想要的其实是解构。为了让 JavaScript 明白这里不是代码块,可以把整个表达式用圆括号 (...) 包起来:
let title, width, height;
// 这样就可以了
({title, width, height} = {title: "Menu", width: 200, height: 100});
alert( title ); // Menu
嵌套解构
如果对象或数组中还包含嵌套的对象和数组,我们可以使用更复杂的左侧模式来提取更深层的数据。下面例子中,options 的 size 属性是一个对象,items 属性是一个数组,左侧模式保持相同结构即可逐层取值:
let options = {
size: {
width: 100,
height: 200
},
items: ["Cake", "Donut"],
extra: true
};
// 为清晰起见,解构赋值拆成多行书写
let {
size: { // 把 size 放这里
width,
height
},
items: [item1, item2], // 把 items 分配到这里
title = "Menu" // 对象中没有此属性(使用默认值)
} = options;
alert(title); // Menu
alert(width); // 100
alert(height); // 200
alert(item1); // Cake
alert(item2); // Donut
options 对象中除了左侧模式未涉及的 extra 之外,其余属性都对应地赋给了变量;最终我们得到 width、height、item1、item2 以及来自默认值的 title。注意:由于我们取的是 size 和 items 的内容,所以并没有生成 size、items 这两个变量。整个赋值过程可以用下图直观表示:
智能函数参数(Smart function parameters)
有时函数有很多参数,其中大部分是可选的——这在用户界面(UI)场景中尤其常见。想象一个创建菜单的函数,它可能有宽度、高度、标题、菜单项列表等参数。
下面是一种不好的写法:
function showMenu(title = "Untitled", width = 200, height = 100, items = []) {
// ...
}
现实中的问题是:调用者很难记住参数的顺序。IDE 通常会在代码有良好文档时给予提示,但依然麻烦;另一个问题是,当大多数参数都可以用默认值时,该如何调用这个函数?难道写成这样吗:
// 默认值的位置填 undefined
showMenu("My Menu", undefined, undefined, ["Item1", "Item2"])
这很难看,参数更多时更不可读。解构赋值正好可以解决这个问题:
我们可以把参数打包成一个对象传入,让函数立即把它们解构成变量:
// 我们把对象传给函数
let options = {
title: "My menu",
items: ["Item1", "Item2"]
};
// ……函数立刻把它展开成变量
function showMenu({title = "Untitled", width = 200, height = 100, items = []}) {
// title、items 取自 options,
// width、height 使用默认值
alert( `${title} ${width} ${height}` ); // My Menu 200 100
alert( items ); // Item1, Item2
}
showMenu(options);
函数参数同样支持更复杂的模式,例如嵌套对象与冒号映射:
let options = {
title: "My menu",
items: ["Item1", "Item2"]
};
function showMenu({
title = "Untitled",
width: w = 100, // width 进入 w
height: h = 200, // height 进入 h
items: [item1, item2] // items 的第一个元素进入 item1,第二个进入 item2
}) {
alert( `${title} ${w} ${h}` ); // My Menu 100 200
alert( item1 ); // Item1
alert( item2 ); // Item2
}
showMenu(options);
这里的完整语法与解构赋值完全一致:
function({
incomingProperty: varName = defaultValue
...
})
即:对于传入的参数对象,属性 incomingProperty 会赋给变量 varName,缺省时使用 defaultValue。
请注意,这种解构模式假设 showMenu() 确实有参数传入。如果我们希望所有值都使用默认值,就必须显式传入一个空对象:
showMenu({}); // 可以,所有值都是默认值
showMenu(); // 这会报错
解决办法是给整个参数对象设置 {} 作为默认值:
function showMenu({ title = "Menu", width = 100, height = 200 } = {}) {
alert( `${title} ${width} ${height}` );
}
showMenu(); // Menu 100 200
上面的代码中,整个参数对象默认是 {},因此永远有东西可以解构。
仓库配套练习与测试验证
本章在仓库中配有针对性练习,可以作为理解与自测的补充材料。
练习一:解构 user
任务描述:已知对象 user = { name: "John", years: 30 },要求写出解构赋值,把 name 读入变量 name、把 years 读入变量 age、把 isAdmin 读入变量 isAdmin(该属性不存在时为 false)。
官方参考答案在一个语句中同时用到了重命名(years: age)和默认值(isAdmin = false)两个特性:
let {name, years: age, isAdmin = false} = user;
alert( name ); // John
alert( age ); // 30
alert( isAdmin ); // false
练习二:最高薪水 topSalary
任务描述:定义函数 topSalary(salaries),返回薪水最高的人名;salaries 为空时返回 null;有多个并列最高者时返回其中任意一个。任务提示使用 Object.entries 与解构遍历键值对。
参考实现正是把本文的"Object.entries + 循环内 [name, salary] 解构"技巧用于实战:
function topSalary(salaries) {
let maxSalary = 0;
let maxName = null;
for(const [name, salary] of Object.entries(salaries)) {
if (maxSalary < salary) {
maxSalary = salary;
maxName = name;
}
}
return maxName;
}
对应的测试用例使用 Mocha 验证了两个关键分支:正常返回最高薪水者("Pete"),以及空对象时返回 null:
describe("topSalary", function() {
it("returns top-paid person", function() {
let salaries = {
"John": 100,
"Pete": 300,
"Mary": 250
};
assert.equal( topSalary(salaries), "Pete" );
});
it("returns null for the empty object", function() {
assert.isNull( topSalary({}) );
});
});
总结与完整语法速查
解构赋值允许我们把对象或数组即时映射到多个变量上,本仓库 1-js/05-data-types/10-destructuring-assignment/article.md 给出的完整语法如下:
-
对象的完整语法:
let {prop : varName = defaultValue, ...rest} = object表示属性
prop应赋给变量varName;如果不存在该属性,则使用defaultValue。没有对应映射的对象属性会被收集进rest对象。 -
数组的完整语法:
let [item1 = defaultValue, item2, ...rest] = array第一个元素进入
item1,第二个进入item2,其余全部组成数组rest。 -
还可以从嵌套的数组/对象中提取数据,此时左侧模式必须与右侧结构保持一致。
-
当左侧不写
let而直接对已有变量解构对象时,需用圆括号({...} = obj)包裹,以免被 JavaScript 误判为代码块。 -
解构赋值在"遍历
Object.entries/Map的键值对""交换变量""为带大量可选参数的函数设计优雅签名"三大场景中尤为常用,是日常 JavaScript 开发必须熟练掌握的语法。