ECMAScript 6 -- 数组的解构赋值

模式匹配:只要等号两边的模式相同,左边的变量就会被赋予对应的值。

let [a, b, c] = [1, 2, 3];

嵌套数组进行解构:

let [foo, [[bar], baz]] = [1, [[2], 3]];
foo // 1
bar // 2
baz // 3

let [ , , third] = ["foo", "bar", "baz"];
third // "baz"

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

let [head, ...tail] = [1, 2, 3, 4];
head // 1
tail // [2, 3, 4]

let [x, y, ...z] = [‘a‘];
x // "a"
y // undefined
z // []

不完全解构:等号左边的模式,只匹配一部分的等号右边的数组。

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

let [a, [b], d] = [1, [2, 3], 4];
a // 1
b // 2
d // 4

只要某种数据结构具有 Iterator 接口,都可以采用数组形式的解构赋值:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
<script>

    function* fibs() {
        let a = 0;
        let b = 1;
        while (true) {
            yield a;
            [a, b] = [b, a + b];
        }
    }

    let [first, second, third, fourth, fifth, sixth] = fibs();
    alert(sixth);
</script>
</body>
</html>

对象的解构赋值

解构不仅可以用于数组,还可以用于对象。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
<script>
    let { foo, bar } = {foo: "aaa", bar: "bbb"};
    console.log(foo);
    console.log(bar);
</script>
</body>
</html>

结果:aaa,bbb

简写:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
<script>
    let obj = { first: ‘hello‘, last: ‘world‘ };
    let { first: f, last: l } = obj;
    console.log(f);
    console.log(l);
</script>
</body>
</html>

结果:

hello

world

数组本质是特殊的对象,因此可以对数组进行对象属性的解构。

如下

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
<script>
let arr = [1, 2, 3];
let {0 : first, [arr.length - 1] : last} = arr;
console.log(first); // 1
console.log(last);  // 3
</script>
</body>
</html>

结果为:

1

3

字符串的解构赋值

字符串也可以解构赋值。这是因为此时,字符串被转换成了一个类似数组的对象。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
<script>
const [a, b, c, d, e] = ‘hello‘;
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"
console.log(a);
console.log(b);
console.log(c);
console.log(d);
console.log(e);

</script>
</body>
</html>

数值和布尔值的解构赋值

解构赋值时,如果等号右边是数值和布尔值,则会先转为对象。

let {toString: s} = 123;
s === Number.prototype.toString // true

let {toString: s} = true;
s === Boolean.prototype.toString // true

函数参数的解构赋值

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
<script>
function move({x = 0, y = 0} = {}) {
    return [x, y];
}
console.log(move({x: 3, y: 8}));
console.log(move({x: 3}));
console.log(move({}));
console.log(move());
</script>
</body>
</html>

结果:

时间: 2024-11-07 16:21:39

ECMAScript 6 -- 数组的解构赋值的相关文章

ES6数组的解构赋值( 下)

对象的解构赋值 对象的解构赋值跟数组的解构赋值很类似,我们来看一段小代码: var { a,b,c} = {"a":1,"b":2,"c":3}; console.log(a);//结果:a的值为1 console.log(b);//结果:b的值为2 console.log(c);//结果:c的值为3 这段例子的代码是不是跟数组的解构赋值很相似,只不过是数组换成了对象.但是两者有一个不同的地方,我们对上面的代码稍做修改: var { a,b,c

ECMAScript中变量的解构赋值

ES6 允许从数组和对象中提取值,对变量进行赋值. 解构赋值的基本用法: 1.数组的解构赋值 let [a, b, c]= [1,2, 3]; console.log(a);//1 console.log(b);//2 console.log(c);//3 2.对象的解构赋值 let { foo:foo2, bar:bar2 } = {foo: "aaa",bar: "bbb" }; console.log(foo2);// "aaa" cons

ES6 之 数组的解构赋值

数组的解构赋值 基本用法 ES6 允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring). 以前,为变量赋值,只能直接指定值. let a = 1;let b = 2;let c = 3; ES6允许写成下面这样. let [a, b, c] = [1, 2, 3]; 上面代码表示,可以从数组中提取值,按照对应位置,对变量赋值. 本质上,这种写法属于“模式匹配”,只要等号两边的模式相同,左边的变量就会被赋予对应的值.下面是一些使用嵌套数组进行解构的例子

数组的解构赋值

基本用法 ES6 允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring). 以前,为变量赋值,只能直接指定值. let a = 1; let b = 2; let c = 3; ES6 允许写成下面这样. let [a, b, c] = [1, 2, 3]; 上面代码表示,可以从数组中提取值,按照对应位置,对变量赋值. 本质上,这种写法属于"模式匹配",只要等号两边的模式相同,左边的变量就会被赋予对应的值.下面是一些使用嵌套数组进行解构的例子

ES6变量的解构赋值(一)数组的解构赋值

let[a,...arr]=[1,2,3,4];//a==>1 arr==>[2,3,4] let [x, y, ...z] = ['a'];//a==>'a' y==>undefined z==> [] let [a, [b], d] = [1, [2, 3], 4];//a==>1 b==>2 c==>4 let[a,b]=[1,2,3];//a==>1 b==>2 数组中变量左右两边一对一对应: let[a,b,c]=[1,2,3];//a

《ECMAScript 6 入门- 第二章 变量的解构赋值》 —— 摘抄

1.数组的解构赋值 ES6允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring). 旧做法: var a = 1; var b = 2; var c = 3; ES6做法: var [a,b,c] = [1,2,3]; 上面代码表示,可以从数组中提取值,按照对应位置,对变量赋值. 本质上,这种写法属于“模式匹配”,只要等号两边的模式相同,左边的变量就会被赋予对应的值.下面是一些使用嵌套数组进行解构的例子. var [foo,[[bar],bad]] =

ECMAScript 6笔记(let,const,变量的解构赋值)

参考阮一峰的书籍ECMAScript 6 入门,感谢阮大神! let和const命令 let命令 ES6新增了let命令,用来声明变量.它的用法类似于var,但是所声明的变量,只在let命令所在的代码块内有效. 基本用法 var a = []; for (var i = 0; i < 10; i++) { a[i] = function () { console.log(i); }; } a[6](); // 10 var a = []; for (let i = 0; i < 10; i++

ECMAScript 6入门 - 变量的解构赋值

定义 ES6允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring). 解构赋值不仅适用于var命令,也适用于let和const命令. 解构赋值的规则是,只要等号右边的值不是对象,就先将其转为对象. 数组的解构赋值 基本用法 'use strict' var [a, b, c] = [1, 2, 3]; a // 1 b // 2 c // 3 嵌套数组解构 'use strict' let [foo, [[bar], baz]] = [1, [[2],

ES6--变量的声明及解构赋值

ES6的目标是使得JavaScript语言可以用来编写大型的复杂的应用程序,成为企业级开发语言:该标准已于2015年6月17日正式发布.但是真正的普及我认为还得需要一段时间,然而这并不是理由让我们不去了解ES6.更重要的一点是,Google公司的V8引擎已经部署了ES6部分特性,对于NodeJS的开发者来说应该熟练掌握. 在浏览器没有全面支持的情况下,Google公司推出了Traceur转码器(https://github.com/google/traceur-compiler),可将ES6编译