现代 JavaScript 教程之解构赋值:数组与对象的解构语法深度指南

原创2026-10-02 18:48:081,864 阅读
文章标签:文档/教程前端

现代 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 这两个变量。整个赋值过程可以用下图直观表示:

解构赋值中左侧模式与右侧 options 对象各层级的对应关系(size 中的 width/height、items 中的 item1/item2 以及默认值 title)

智能函数参数(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 开发必须熟练掌握的语法。

登录后查看全文
en.javascript.info