一, 基本语法
1.1, 声明变量的六种方法
参看地址: http://es6.ruanyifeng.com/#docs/let
let: 局部变量, 块级作用域, 声明前使用报错
var: 全局变量, 声明前使用 undefined
const: 声明一个只读的常量. 一旦声明, 常量的值就不能改变. 只是内存地址不变, 如果是对象, 内存不变属性对应的值可变
- function:
- import:
- class:
参看地址: http://es6.ruanyifeng.com/#docs/destructuring
1.2.1, 数组
- 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 [foo] = []; //foo undefined
- let [bar, foo] = [1];//foo undefined
如果等号的右边不是数组(或者严格地说, 不是可遍历的结构, 参见Iterator一章), 那么将会报错.
支持 Set
- let [x, y, z] = new Set(['a', 'b', 'c']);
- x // "a"
- 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();
- sixth // 5
上面代码中, fibs 是一个 Generator 函数(参见Generator 函数一章), 原生具有 Iterator 接口. 解构赋值会依次从这个接口获取值.
默认值
- let [foo = true] = [];
- foo // true
- let [x, y = 'b'] = ['a']; // x='a', y='b'
- let [x, y = 'b'] = ['a', undefined]; // x='a', y='b'
注意, ES6 内部使用严格相等运算符(===), 判断一个位置是否有值. 所以, 只有当一个数组成员严格等于 undefined, 默认值才会生效.
如果默认值是一个表达式, 那么这个表达式是惰性求值的, 即只有在用到的时候, 才会求值.
- function f() {
- console.log('aaa');
- }
- let [x = f()] = [1];
上面代码中, 因为 x 能取到值, 所以函数 f 根本不会执行. 上面的代码其实等价于下面的代码.
- let x;
- if ([1][0] === undefined) {
- x = f();
- } else {
- x = [1][0];
- }
1.2.2, 对象
对象的解构与数组有一个重要的不同. 数组的元素是按次序排列的, 变量的取值由它的位置决定; 而对象的属性没有次序, 变量必须与属性同名, 才能取到正确的值.
- let { bar, foo } = { foo: "aaa", bar: "bbb" };
- foo // "aaa"
- bar // "bbb"
- let { baz } = { foo: "aaa", bar: "bbb" };
- baz // undefined
如果变量名与属性名不一致, 必须写成下面这样.
- let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
- baz // "aaa"
- let obj = { first: 'hello', last: 'world' };
- let { first: f, last: l } = obj;
- f // 'hello'
- l // 'world'
1.2.3, 字符串
字符串也可以解构赋值. 这是因为此时, 字符串被转换成了一个类似数组的对象.
- const [a, b, c, d, e] = 'hello';
- a // "h"
- b // "e"
- c // "l"
- d // "l"
- e // "o"
类似数组的对象都有一个 length 属性, 因此还可以对这个属性解构赋值.
- let {length : len} = 'hello';
- len // 5
1.2.4, 数值和布尔值的解构赋值
- let {toString: s} = 123;
- s === Number.prototype.toString // true
- let {toString: s} = true;
- s === Boolean.prototype.toString // true
上面代码中, 数值和布尔值的包装对象都有 toString 属性, 因此变量 s 都能取到值.
解构赋值的规则是, 只要等号右边的值不是对象或数组, 就先将其转为对象. 由于 undefined 和 null 无法转为对象, 所以对它们进行解构赋值, 都会报错.
- let { prop: x } = undefined; // TypeError
- let { prop: y } = null; // TypeError
1.2.5, 函数参数的解构赋值
- function add([x, y]){
- return x + y;
- }
- add([1, 2]); // 3
上面代码中, 函数 add 的参数表面上是一个数组, 但在传入参数的那一刻, 数组参数就被解构成变量 x 和 y. 对于函数内部的代码来说, 它们能感受到的参数就是 x 和 y.
下面是另一个例子.
- [[1, 2], [3, 4]].map(([a, b]) => a + b);
- // [ 3, 7 ]
函数参数的解构也可以使用默认值.
- function move({x = 0, y = 0} = {}) {
- return [x, y];
- }
- move({x: 3, y: 8}); // [3, 8]
- move({x: 3}); // [3, 0]
- move({}); // [0, 0]
- move(); // [0, 0]
上面代码中, 函数 move 的参数是一个对象, 通过对这个对象进行解构, 得到变量 x 和 y 的值. 如果解构失败, x 和 y 等于默认值.
注意, 下面的写法会得到不一样的结果.
- function move({x, y} = { x: 0, y: 0 }) {
- return [x, y];
- }
- move({x: 3, y: 8}); // [3, 8]
- move({x: 3}); // [3, undefined]
- move({}); // [undefined, undefined]
- move(); // [0, 0]
上面代码是为函数 move 的参数指定默认值, 而不是为变量 x 和 y 指定默认值, 所以会得到与前一种写法不同的结果.
undefined 就会触发函数参数的默认值.
- [1, undefined, 3].map((x = 'yes') => x);
- // [ 1, 'yes', 3 ]
解构赋值虽然很方便, 但是解析起来并不容易. 对于编译器来说, 一个式子到底是模式, 还是表达式, 没有办法从一开始就知道, 必须解析到 (或解析不到) 等号才能知道.
由此带来的问题是, 如果模式中出现圆括号怎么处理. ES6 的规则是, 只要有可能导致解构的歧义, 就不得使用圆括号.
但是, 这条规则实际上不那么容易辨别, 处理起来相当麻烦. 因此, 建议只要有可能, 就不要在模式中放置圆括号.
1.3, 主要用途
(1)交换变量的值
- let x = 1;
- let y = 2;
- [x, y] = [y, x];
(2)从函数返回多个值
函数只能返回一个值, 如果要返回多个值, 只能将它们放在数组或对象里返回. 有了解构赋值, 取出这些值就非常方便.
- // 返回一个数组
- function example() {
- return [1, 2, 3];
- }
- let [a, b, c] = example();
- // 返回一个对象
- function example() {
- return {
- foo: 1,
- bar: 2
- };
- }
- let { foo, bar } = example();
(3)函数参数的定义
解构赋值可以方便地将一组参数与变量名对应起来.
// 参数是一组有次序的值
function f([x, y, z]) { ... }
- f([1, 2, 3]);
- // 参数是一组无次序的值
function f({x, y, z}) { ... }
f({z: 3, y: 2, x: 1});
(4)提取 JSON 数据
解构赋值对提取 JSON 对象中的数据, 尤其有用.
- let jsonData = {
- id: 42,
- status: "OK",
- data: [867, 5309]
- };
- let { id, status, data: number } = jsonData;
- console.log(id, status, number);
- // 42, "OK", [867, 5309]
(5)函数参数的默认值
- jQuery.ajax = function (url, {
- async = true,
- beforeSend = function () {},
- cache = true,
- complete = function () {},
- crossDomain = false,
- global = true,
- // ... more config
- } = {}) {
- // ... do stuff
- };
指定参数的默认值, 就避免了在函数体内部再写
var foo = config.foo || 'default foo';
这样的语句.
(6)遍历 Map 结构
任何部署了 Iterator 接口的对象, 都可以用 for...of 循环遍历. Map 结构原生支持 Iterator 接口, 配合变量的解构赋值, 获取键名和键值就非常方便.
- const map = new Map();
- map.set('first', 'hello');
- map.set('second', 'world');
- for (let [key, value] of map) {
- console.log(key + "is" + value);
- }
- // first is hello
- // second is world
如果只想获取键名, 或者只想获取键值, 可以写成下面这样.
- // 获取键名
- for (let [key] of map) {
- // ...
- }
- // 获取键值
- for (let [,value] of map) {
- // ...
- }
(7)输入模块的指定方法
加载模块时, 往往需要指定输入哪些方法. 解构赋值使得输入语句非常清晰.
const { SourceMapConsumer, SourceNode } = require("source-map");
001-es6 变量声明, 解构赋值, 解构赋值主要用途
来源: http://www.bubuko.com/infodetail-2582793.html