不用一行行点属性了:解构赋值实战指南
订单是一组字段拼成的对象,菜单是一列菜品,取字段、取返回值、取函数参数,全是解构的活。本文按 MDN 的解构赋值参考文档讲清楚:数组按位置、对象按名字、改名与默认值、绑定与赋值两种模式、括号陷阱、rest、函数参数与嵌套解构。

先把这篇的边界说清楚。站里已经有《数组方法实战指南》,讲的是手里有一列东西怎么加工;还有《Promise 与 async/await 实战指南》,讲的是等一个结果回来有几种写法;还有《闭包与作用域实战指南》,讲的是变量谁能看见。这篇不讲加工列表、不讲等结果、不讲变量,只讲一件事:手里有一个对象或者一个数组,怎么把它里面的东西一次拆成几个变量。拆对了,取值的代码能短一半,也好读一半。下面用到的“青石咖啡馆”还是那个虚构的练手项目:一个帮街边咖啡馆做点单的网页小工具。这回讲的是它的订单、菜单和用户资料:订单是一组字段拼成的对象,菜单是一列菜品,取字段、取返回值、取函数参数,全是解构的活。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于解构的语法和行为,都来自 MDN 的《Destructuring assignment(解构赋值)》参考文档,来源见每篇的 meta 信息与 evidence 记录。MDN 文档里的例子,比如红黄绿三色、用户 Jane Doe、元数据 Scratchpad,都是文档自带的示例,不是真实用户数据。
第一步:解构是打包的反向操作
写 const arr = [a, b, c] 是把三个值打包成一个数组;写 const [a, b, c] = arr 是反过来,把数组拆成三个变量。MDN 的原话是:解构用的语法和字面量差不多,只是放在了赋值号的左边,做的事正好是声明一个数组的反向操作。对象也一样:const obj = { a, b, c } 是打包,const { a, b, c } = obj 是拆开,等价于 const a = obj.a, b = obj.b, c = obj.c。属性名和变量名不一样的时候,写冒号改名:const obj = { prop1: x, prop2: y, prop3: z },const { prop1: x, prop2: y, prop3: z } = obj,意思就是 const x = obj.prop1, y = obj.prop2, z = obj.prop3。MDN 还提了一句:这种能力在 Perl 和 Python 这类语言里也有,不算 JavaScript 的独创。咖啡馆的订单就是这么拆的:订单对象里有菜名、数量、单价三个字段,一行 const { dish, count, price } = order,全取出来了,不用再写三行 order.dish、order.count、order.price。记住第一句话:打包用字面量,拆包用解构,左右两边的形状要对得上。
第二步:数组解构按位置对号入座,多了的变量是 undefined
数组解构不看名字,只看位置。MDN 的例子是:const foo = ["one", "two", "three"],const [red, yellow, green] = foo,red 是 "one",yellow 是 "two",green 是 "three"。第一个变量拿第一个元素,第二个拿第二个,以此类推。左边变量比右边元素多的时候,多出来的变量拿不到东西,就是 undefined。MDN 的例子是:const foo = ["one", "two"],const [red, yellow, green, blue] = foo,red 是 "one",yellow 是 "two",green 和 blue 都是 undefined。反过来,右边元素比左边变量多,多出来的元素没人要,直接丢掉,不会报错。咖啡馆的菜单排序就踩过这个坑:想取销量前三的菜,写了 const [first, second, third, fourth] = topList,可那天只卖出了两种菜,fourth 是 undefined,页面上多出一张空白卡片。记住判断句:数组解构只认位置不认名字,数一数两边的个数,多的那头要想清楚去向。
第三步:对象解构按名字对号入座,还能顺手改名
对象解构不看位置,只看名字。MDN 的例子是:const user = { id: 42, isVerified: true },const { id, isVerified } = user,id 是 42,isVerified 是 true。名字对上就取得到,对象里属性的顺序根本不重要。想换个变量名,冒号后面写新名字:const o = { p: 42, q: true },const { p: foo, q: bar } = o,foo 是 42,bar 是 true。MDN 的原话是:const { p: foo } = o 这句,是从对象 o 里取出名字叫 p 的属性,交给本地变量 foo。改名还能顺带给默认值:const { a: aa = 10, b: bb = 5 } = { a: 3 },aa 是 3,bb 是 5,因为对象里没有 b。咖啡馆的用户资料就是这么取的:用户对象里有个 displayName,页面上的变量名想叫 dname,写 const { displayName: dname } = user,一行搞定,不用先取出来再换名。记住判断句:对象解构只认名字不认位置,冒号左边是属性名,冒号右边才是你的变量名。
第四步:绑定模式与赋值模式是两套写法,别混着用
解构有两种模式,MDN 分得很清楚。绑定模式以声明关键字开头:var、let 或者 const,后面每个属性要么绑一个变量,要么继续往下拆。MDN 的例子是:const obj = { a: 1, b: { c: 2 } },const { a, b: { c: d } } = obj,绑出来的只有两个变量:a 和 d。注意,所有变量共用同一个声明:如果想让一部分变量能改、另一部分只读,得拆两次,一次用 const、一次用 let。MDN 的例子是:const { a } = obj,a 是常量;let { b: { c: d } } = obj,d 能重新赋值。赋值模式不以关键字开头,拆出来的东西交给一个赋值目标:可以是事先声明好的变量,也可以是另一个对象的属性。MDN 的例子是:const numbers = [],const obj = { a: 1, b: 2 },({ a: numbers[0], b: numbers[1] } = obj),a 和 b 分别写进了 numbers[0] 和 numbers[1]。反过来,绑定模式里这么写是无效的:const { a: numbers[0], b: numbers[1] } = obj 等价于 const numbers[0] = obj.a,根本不是合法语法。还有一条:赋值模式只能出现在赋值号 = 的左边,不能和 +=、*= 这类复合赋值号一起用。咖啡馆的点单页就踩过这个坑:想把订单的两个字段直接写进已有的数组,套了 const 写法,编辑器直接报红。记住判断句:声明新变量用绑定模式,往已有地方写值用赋值模式,两种模式的语法不能互换。
第五步:对象赋值不加括号,代码就散了
这是解构里最出名的坑,MDN 专门用粗体提醒:不带声明的对象解构赋值,括号是必须的。写 { a, b } = { a: 1, b: 2 } 单独成句是无效语法,因为行首的 { a, b } 会被当成一个代码块,而不是对象字面量。正确的写法是 ({ a, b } = { a: 1, b: 2 }),括号一包,意思就清楚了;带声明的 const { a, b } = { a: 1, b: 2 } 不用括号,因为 const 开头已经说明这不是代码块。还有一个连带坑:如果你的代码风格不写行尾分号,括号表达式前面必须补一个分号,否则它会跟上一行连起来,被当成调用上一行那个值的函数。咖啡馆的订单页就踩过这个坑:一段赋值代码前面没加分号,上一行的变量被当成函数执行,页面直接报错。记住判断句:对象赋值解构,左边的花括号一定要包在圆括号里;不写分号的风格,括号前面再补一个分号。
第六步:默认值只救 undefined,不救 null
拆出来的每个属性都可以带一个默认值,写法是在变量名后面写 = 默认值。默认值什么时候生效,MDN 说得很死:属性不存在,或者属性的值是 undefined 时生效;属性的值是 null 时不生效。MDN 的例子是:const [a = 1] = [],a 是 1;const { b = 2 } = { b: undefined },b 是 2;const { c = 2 } = { c: null },c 是 null,不是 2。也就是说,默认值救的是“没给”和“给了个 undefined”,救不了“给了个 null”。默认值还可以是任意表达式,而且只在需要的时候才求值。MDN 的例子是:const { b = console.log("hey") } = { b: 2 },什么都没打印,因为 b 已经有值了,根本不需要算默认值。咖啡馆的菜单项就踩过这个坑:后端返回的折扣字段有时是 null,前端写了 const { discount = 0 } = dish,以为能兜底,结果 null 原样留了下来,价格算出来是 NaN。记住判断句:默认值只管 undefined,不管 null;后端可能返回 null 的字段,先判 null,再谈默认值。
第七步:rest 永远放最后,拿到的是新容器
解构模式的末尾可以跟一个 rest 属性,写法是 ...rest。数组解构里,它把剩下的元素收进一个新数组;对象解构里,它把没被挑走的可枚举自有属性复制进一个新对象。MDN 的例子是:const { a, ...others } = { a: 1, b: 2, c: 3 },others 是 { b: 2, c: 3 };const [first, ...others2] = [1, 2, 3],others2 是 [2, 3]。两条铁律:rest 必须是模式里的最后一个,不能有尾逗号。MDN 的例子是:const [a, ...b,] = [1, 2, 3] 直接报 SyntaxError:rest 元素后面不能有尾逗号。还有一条容易误解的:rest 造出来的容器是新的,但里面的成员如果本身是对象,引用还是原来的那一个,语言不会替你深拷贝。MDN 的原话是:和其他语言特性一样,这里没有隐式的深拷贝,rest 属性创建了一个新对象或者新数组,但它的成员值如果是对象引用,仍然指向同一个对象。数组的 rest 还能再套一层绑定模式:const [a, b, ...{ pop, push }] = array,能从收起来的剩余数组上再拆出 pop 和 push;const [a, b, ...[c, d]] = array,能继续按位置拆。对象就不行:const { a, ...{ b } } = { a: 1, b: 2 } 会报错,对象 rest 后面只能跟一个标识符。咖啡馆的订单过滤就是这么写的:const { id, ...rest } = order,id 单独拿走,rest 就是去掉 id 的其余字段,直接传给下一个组件。记住判断句:rest 永远放最后、后面不加逗号;它给的是新容器,不是深拷贝。
第八步:换两个变量的值,不用临时变量
不用解构的时候,交换两个变量的值得先找一个临时变量中转:temp = a,a = b,b = temp,三行代码。解构一句话就够了。MDN 的例子是:let a = 1,let b = 3,[a, b] = [b, a],a 变成 3,b 变成 1。右边的 [b, a] 先算出一个新数组 [3, 1],左边的 [a, b] 再按位置拆回去,交换就完成了。数组里的两个元素也能这么换:const arr = [1, 2, 3],[arr[2], arr[1]] = [arr[1], arr[2]],arr 变成 [1, 3, 2]。注意这里用的是赋值模式:a、b 和 arr 都是事先声明好的,左边没有 const,所以这是一次赋值,不是一次声明。咖啡馆的菜单排序就用上了这一招:用户点一下“上移”,当前菜和上一道菜交换位置,一行 [menu[i], menu[i - 1]] = [menu[i - 1], menu[i]],不用临时变量,也不用 splice。记住判断句:交换两个值,右边先拼一个新数组,左边按位置拆回去,一行写完。
第九步:函数返回数组,一行拆开;不想要的用逗号跳过
函数返回数组的时候,解构能让取返回值的代码短很多。MDN 的例子是:function f() { return [1, 2]; },const [a, b] = f(),a 是 1,b 是 2。不想要的返回值,用逗号留空跳过:function f() { return [1, 2, 3]; },const [a, , b] = f(),a 是 1,b 是 3,中间的 2 没人要;const [c] = f(),c 是 1,只要第一个。想全都不要,也可以写 [, ,] = f(),不过 MDN 提醒:这种情况下直接调用函数、不解构更清楚,毕竟返回值根本没人用。咖啡馆的正则解析就是这么写的:MDN 的 parseProtocol 例子里,正则 exec 返回的数组第一个元素是完整匹配,后面才是分组,写 const [, protocol, fullHost, fullPath] = parsedURL,开头一个逗号就把完整匹配跳过去了,protocol 直接拿到 "https"。记住判断句:返回值按位置拆,不想要的留空逗号;全都不要就别解构,直接调用。
第十步:函数参数也能解构,默认值要写全
传进函数的对象参数,也可以在形参位置直接拆开。MDN 的例子用了一个用户对象:const user = { id: 42, displayName: "jdoe", fullName: { firstName: "Jane", lastName: "Doe" } }。只取 id:function userId({ id }) { return id; },userId(user) 返回 42。改名也行:function userDisplayName({ displayName: dname }) { return dname; },userDisplayName(user) 返回 "jdoe"。嵌套也能拆:function whois({ displayName, fullName: { firstName: name } }) { return `${displayName} is ${name}`; },whois(user) 返回 "jdoe is Jane"。参数还能带默认值:MDN 的 drawChart 例子是 function drawChart({ size = "big", coords = { x: 0, y: 0 }, radius = 25 } = {}),调用时传 { coords: { x: 18, y: 30 }, radius: 30 },size 用默认值 "big"。关键在形参末尾那个 = {}:它是整个解构模式的默认值。MDN 说得很清楚:如果不写它,函数要求至少传一个参数;写了它,drawChart() 一个参数不传也能调用。咖啡馆的点单函数就踩过这个坑:function renderOrder({ dish, count } = {}) 写成了 function renderOrder({ dish, count }),首页有个地方调用时没传参数,页面直接抛错。记住判断句:参数解构必配 = {},默认值写在两层:属性一层、整个对象一层。
第十一步:嵌套拆、循环里拆、数组对象混着拆
解构可以一层套一层,拆到你想要的那一级为止。MDN 的元数据例子是:const metadata = { title: "Scratchpad", translations: [{ locale: "de", title: "JavaScript-Umgebung", url: "/de/docs/Tools/Scratchpad" }], url: "/en-US/docs/Tools/Scratchpad" },const { title: englishTitle, translations: [{ title: localeTitle }] } = metadata,englishTitle 是 "Scratchpad",localeTitle 是 "JavaScript-Umgebung"。注意,中间的 translations 数组和里面的对象本身并没有被绑成变量,绑出来的只有改名后的那两个。循环变量也能解构:MDN 的例子是 people 数组里每人有 name 和 family,for (const { name: n, family: { father: f } } of people),直接打印 "Name: Mike Smith, Father: Harry Smith"。数组和对象还能混着拆:MDN 的例子是 const props = [{ id: 1, name: "Fizz" }, { id: 2, name: "Buzz" }, { id: 3, name: "FizzBuzz" }],const [, , { name }] = props,前面两个逗号跳过前两项,第三项拆出 name,得到 "FizzBuzz"。咖啡馆的订单列表渲染就是这么写的:for (const { dish, count } of orders),循环变量一拆,dish 和 count 直接能用,不用在循环体里再写 order.dish。记住判断句:嵌套解构只绑最里层的名字,中间层只是路过;循环变量拆开,循环体就干净了。
第十二步:计算属性名与带横线的属性名
属性名不一定是写死的字面量,也可能是存在变量里的字符串。MDN 的例子是:const key = "z",const { [key]: foo } = { z: "bar" },foo 是 "bar"。方括号里的 key 先算出 "z",再按这个名字去取属性。还有一类属性名,根本不是合法的 JavaScript 标识符:比如带横线的 "fizz-buzz"。MDN 的例子是:const foo = { "fizz-buzz": true },const { "fizz-buzz": fizzBuzz } = foo,fizzBuzz 是 true。引号加冒号,左边的引号里写原属性名,冒号右边写一个合法的变量名,就绕过去了。咖啡馆的菜品数据就踩过这个坑:后端返回的字段名是 "spicy-level",前端直接写 const { spicy-level } = dish,编辑器报红,改成 const { "spicy-level": spicyLevel } = dish 就好了。记住判断句:属性名在变量里,用方括号算出来;属性名不是合法标识符,用引号加冒号改名。
第十三步:数组解构走可迭代协议,对象解构沿原型链找
数组解构的右边不一定是数组,只要是可迭代对象就行。MDN 的例子是:const [a, b] = new Map([[1, 2], [3, 4]]),a 是 [1, 2],b 是 [3, 4]。不是可迭代对象就拆不了:const obj = { 0: "a", 1: "b", length: 2 },const [a, b] = obj,直接抛 TypeError:obj is not iterable——长得像数组不等于能迭代,数组方法指南里讲过的类数组对象,这里同样拆不了。还有一个细节:可迭代对象只会被取到够用为止。MDN 的生成器例子是:一个每次打印数字再产出值的可迭代对象,const [a, b] = obj 只打印 0 和 1;但带上 rest 的 const [a, b, ...rest] = obj 会把 0、1、2、3 全打印出来,因为 rest 要把剩余的全部收走。对象解构的查找规则也不一样:属性不在对象自己身上,就沿着原型链往上找。MDN 的例子是:const obj = { self: "123", __proto__: { prot: "456" } },const { self, prot } = obj,self 是 "123",prot 是 "456"。最后是两条红线:解构 null 或者 undefined 会抛 TypeError,const { a } = undefined 报错,const { b } = null 报错,连空模式 const {} = null 也报错;但解构原始值不会报错,值会被包进对应的包装对象再取属性,const { a, toFixed } = 1 里,a 是 undefined,toFixed 是数字的方法。咖啡馆的订单详情页就踩过这个坑:订单还没加载完是 null,页面一上来就 const { dish } = order,直接白屏。记住判断句:数组解构先问“能不能迭代”,对象解构先问“是不是 null”;原型链上的属性,解构一样找得到。
第十四步:90 次解构事故,先对着图自查

上图是虚构的青石咖啡馆项目一个月的统计:和解构相关的事故一共 90 次。忘写括号、对象赋值被当成代码块 27 次,占 30.0%,是最多的;默认值只救 undefined、不救 null,null 原样留下 18 次,占 20.0%;rest 没放最后、还带了尾逗号 18 次,占 20.0%;函数参数解构没给默认空对象、调用时不传参就报错 15 次,占 16.7%;对 null 或者 undefined 解构、直接抛错 12 次,占 13.3%。27 加 18 加 18 加 15 加 12 等于 90,账是平的。这些数字是编出来的例子,目的是让你一眼看到:第一类占了快三分之一,而它的根源只有一个——对象赋值解构的括号不是可选项,是语法的一部分。
自查清单:写完带解构的代码,逐条打勾
第一,打包用字面量,拆包用解构,数组按位置、对象按名字,左右形状对得上。第二,数组变量多了是 undefined,对象属性多了直接丢掉,数一数两边的个数。第三,改名用冒号,冒号左边是属性名、右边是你的变量名,改名还能顺带给默认值。第四,声明新变量用绑定模式,往已有地方写值用赋值模式,const { a: numbers[0] } 这种混写法无效。第五,对象赋值解构一定加括号,不写分号的风格,括号前面再补一个分号。第六,默认值只救 undefined、不救 null,null 字段先判 null 再谈默认值;默认值只在需要时才求值。第七,rest 永远放最后、后面不加逗号;它给的是新容器,不是深拷贝。第八,交换两个值,右边先拼一个新数组,左边按位置拆回去。第九,函数返回值按位置拆,不想要的留空逗号,全都不要就别解构。第十,函数参数解构必配 = {},属性一层、整个对象一层,默认值都要写。第十一,嵌套解构只绑最里层的名字,循环变量拆开,循环体就干净了。第十二,属性名在变量里用方括号算出来,带横线的属性名用引号加冒号改名。第十三,数组解构先问“能不能迭代”,对象解构先问“是不是 null”;原型链上的属性,解构一样找得到。十三条里任何一条答不上来,回到对应的章节再读一遍,比多背十个 API 都有用。
评论 (0)
原始来源
相关文章
localStorage 只能存字符串、没有索引。IndexedDB 是浏览器里真正的数据库:能存结构化数据、容量大得多、能建索引、能用事务。本文按 MDN 的《Using IndexedDB》《IDBDatabase》《IDBObjectStore》三篇官方文档讲清楚:五步套路、开库、升级、主键、索引、事务、add 与 put、get、游标、范围与多标签页升级。
函数你每天都在调,这篇把你一直在做的事讲清楚。本文按 MDN 的《Functions》《Arrow function expressions》《Rest parameters》三篇官方文档讲清楚:声明与表达式、参数与实参、默认值、剩余参数、展开语法、返回值、箭头函数省写规则、this 的坑、回调与高阶函数、作用域。
同一个页面要在手机、平板、电脑上都站得住。本文按 MDN 的《Responsive web design》《Using media queries》《viewport meta 参考》三篇官方文档讲清楚:流式 HTML、viewport 标签、流式网格与 max-width、图片不撑破容器、媒体查询语法、按内容定断点、mobile-first、响应式字号、按能力查设备与上线检查清单。