JavaScript基础与进阶

数组的解构赋值

基本用法

解构：按照一定模式从数组和对象中提取值，然后对变量进行赋值。

let a = 1;
let b = 2;
let c = 3;
//可写为
let [a,b,c]=[1,2,3];

本质上，这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。

//模式匹配  例如：
let [foo,[[bar], baz]]=[1,[[2],3]];

如果解构不成功，变量的值就等于undefined。

//没有变量接收的解构值会被忽略掉。
let [a, [b], d] = [1, [2, 3], 4];

//如果赋值不是数组则会报错。
let [foo] = 1;

默认值

1.解构赋值允许指定默认值。

//例如：
let [foo = true] = [];
let [x, y = 'b'] = ['a'];
let [m, n = 'b'] = ['a', undefined];

2.默认值可以引用解构赋值的其他变量，但改变量必须已经声明，否则会报错。

let [x = 1, y = x] = [];
let [x = 1, y = x] = [2];
let [x = 1, y = x] = [1, 2];
let [x = y, y = 1] = [];

常见代码

// 常见数组解构赋值
{
    // 数组方式直接赋值
    let a,b,rest;
    [a,b]=[1,2];
    console.log(a,b);
}
{
    // ...rest显示为[3,4,5,6]这个数组
    let a,b,rest;
    [a,b,...rest]=[1,2,3,4,5,6];
    console.log(a,b,rest);
}

// 默认值
{
// 可在左侧直接赋值(例如c=3)，若不赋值则表示没有配对成功，结果为undefined
    let a,b,c,rest;
    [a,b,c=3]=[1,2];
    console.log(a,b,c);
}
{
//实现变量的交换，交换a,b的值
    let a=1;
    let b=2;
    [a,b]=[b,a];
    console.log(a,b);
}

// 直接进行解构赋值
{
    function f(){
        return [1,2];
    }
    let a,b;
    [a,b]=f();
    console.log(a,b);
}

// 当返回多个值的时候，可选择性接受某几个变量(一一对应)
{
    function f(){
        return [1,2,3,4,5];
    }
    let a,b,c;
    [a,,,b]=f();
    console.log(a,b);
}

// 只返回第一个，其余的返回数组
{
    function f(){
        return [1,2,3,4,5];
    }
    let a,b,c;
    [a,...b]=f();
    console.log(a,b);
}

对象的解构赋值

基本用法

1.对象的属性没有次序，变量必须与属性同名才能取到正确的值。

//例如
let { bar, foo } = { foo: "aaa", bar: "bbb" };
let { bar } = { foo: "aaa", bar: "bbb" };

2.如果变量名与属性名不一致，必须明确对应关系。

//例如
let { bar } = { foo: "aaa", bar: "bbb" };
let {foo: bar} = {foo:'aaa', bar:'bbb'};

对象解构赋值内部机制是先找到同名属性，然后再赋值给对应的变量，真正被赋值的是后者。

let { bar, foo } = { foo: "aaa", bar: "bbb" };
//也可写为
let { foo: foo, bar: bar } = { foo: 'aaa', bar: 'bbb' };
//foo（前）是匹配模式，foo（后）才是变量。

3.对象解构赋值也可以用于嵌套结构的对象。

let obj={
    p:[
        'hello',
        {y:'world'}
    ]
};
let{p:[x,{y}]}=obj;
console.log(obj);

4.对象解构赋值也指定默认值，且默认值生效条件是对象的属性严格等于undefined。

var { x = 3 } = {};
var { x, y = 5 } = { x: 1 };
var { x: y = 5 } = {};
var { x: y = 3 } = { x: 5 };

5.对象解构赋值可以很方便地将现有对象的方法赋值给某个变量。

let { log, sin, cos } = Math;

常见代码

// 常见对象解构赋值
{
    let a,b;
    ({a,b}={a:1,b:2})
    console.log(a,b);
}

// 对象解构赋值：左侧和右侧都是对象结构的格式，按照key value方式匹配的
{
    let o={p:42,q:true};
    let {p,q}=o;
    console.log(p,q);
}

// 默认值
{
//右侧的3把左侧的10覆盖，进行重新赋值，所以a为3，b依旧为5
    let {a=10,b=5}={a:3};
    console.log(a,b);
}

字符串的解构赋值

基本用法

字符串的解构赋值，将字符串看作一个类似于数组的对象。

//例如：
const [a, b, c, d] = 'hello';

类似数组的对象都有一个length属性，因此还可以对这个属性进行解构。

let { length: len } = 'hello';

函数参数的解构赋值

基本用法

函数调用时，会将实参传递给形参，其过程就是实参赋值给形参。因此，也可以使用解构赋值。

//参数采用数组赋值方式
function add([x, y = 10]) {
	return x + y;
}
let r = add([1]);

//参数采用对象赋值方式
function add({ x, y = 10 }) {
	return x + y;
}
let r = add({ x: 20 });

解构赋值的用途

1.交换变量的值

let x = 1, y = 3;
[x, y] = [y, x];

2.从函数返回多个值

function func() {
	return [1, 2, 3];
}
let [a, b, c] = func();

function func() {
return {
	foo: 1,
	bar: 2
};
}
let { foo, bar } = func();

3.方便将一组参数与变量名对应起来

function f([x, y, z]) {
	//一组有序参数
}
f([1, 2, 3]);

function f({ x, y, z }) {
	//一组无序参数
}
f({ z: 3, x: 1, y: 2 });

4.提取JSON数据

const json = '{"id": 42,"status": "OK","d": [867, 5309]}';
let data = JSON.parse(json);
let { id, status, d: numbers } = data;
console.log(id, status, numbers);