ES6中的解构赋值

1. 数组解构赋值：

  使用方括号[]来进行数组解构赋值。可以根据数组的结构，将其中的值赋给对应的变量。

const numbers = [1, 2, 3, 4, 5];

const [a, b, c, d, e] = numbers;

console.log(a); // 输出 1
console.log(b); // 输出 2
console.log(c); // 输出 3
console.log(d); // 输出 4
console.log(e); // 输出 5

  除了基本的数组解构赋值外，还可以使用默认值来处理解构时可能不存在的元素。

const numbers = [1, 2];

const [a, b, c = 3] = numbers;

console.log(a); // 输出 1
console.log(b); // 输出 2
console.log(c); // 输出 3

1.1 嵌套数组的解构赋值：

  当处理嵌套的数组时，可以使用多个方括号[]来表示不同层级的解构赋值。

const nestedArray = [1, [2, [3, 4]]];
const [a, [b, [c, d]]] = nestedArray;

console.log(a); // 输出 1
console.log(b); // 输出 2
console.log(c); // 输出 3
console.log(d); // 输出 4

2. 对象解构赋值：

  使用花括号{}来进行对象解构赋值。可以根据对象的属性，将对应的值赋给变量。

const person = {
  name: 'Alice',
  age: 30,
  city: 'New York'
};

const { name, age, city } = person;

console.log(name); // 输出 'Alice'
console.log(age); // 输出 30
console.log(city); // 输出 'New York'

  对象解构赋值也支持默认值的设置。

const person = {
  name: 'Alice',
  age: 30
};

const { name, age, city = 'New York' } = person;

console.log(name); // 输出 'Alice'
console.log(age); // 输出 30
console.log(city); // 输出 'New York'

2.1 嵌套对象的解构赋值：

  当处理嵌套的对象时，可以使用多个花括号{}来表示不同层级的解构赋值。

const nestedObject = {
  prop1: 'value1',
  prop2: {
    nestedProp1: 'value2',
    nestedProp2: {
      deeplyNestedProp: 'value3'
    }
  }
};

const { prop1, prop2: { nestedProp1, nestedProp2: { deeplyNestedProp } } } = nestedObject;

console.log(prop1); // 输出 'value1'
console.log(nestedProp1); // 输出 'value2'
console.log(deeplyNestedProp); // 输出 'value3'

3. 函数参数的解构赋值

3.1 对象解构赋值作为函数参数：

function printUserInfo({ name, age, city }) {
  console.log(`Name: ${name}`);
  console.log(`Age: ${age}`);
  console.log(`City: ${city}`);
}

const user = {
  name: 'Alice',
  age: 30,
  city: 'New York'
};

printUserInfo(user);

  在上面的例子中，我们定义了一个 printUserInfo 函数，它使用对象解构赋值作为函数参数。函数参数 { name, age, city } 指定了我们希望从传递的对象中提取的属性。当我们调用 printUserInfo 函数时，直接传递了一个对象参数 user，函数内部会根据解构赋值语法从对象中提取相应属性的值并打印出来。

3.2 数组解构赋值作为函数参数：

function sum([a, b, c]) {
  console.log(a + b + c);
}

const numbers = [1, 2, 3];

sum(numbers);

  在上面的例子中，我们定义了一个 sum 函数，它使用数组解构赋值作为函数参数。函数参数 [a, b, c] 指定了我们希望从传递的数组中提取的元素。当我们调用 sum 函数时，直接传递了一个数组参数 numbers，函数内部会根据解构赋值语法从数组中提取相应元素的值并计算它们的和。