读深入ES6记[三]

ES6

第五章：不定参数和默认值

1.解决的问题

可用来代替arguments，解决它存在的可读性和参数索引的问题。用个栗子来说明吧

• arguments版本

function foo1(firstParam) {
  // 不熟悉的人真摸不着头脑，这arguments，哪里来的啊
  // 注意索引从1开始，因为0是firstParam
  for (var i = 1, leng = arguments.length; i < leng; i++) {
    console.log(`other param: ${arguments[i]}`);
  }
}
foo1('a', 'b', 'c');

• 不定参数版本

function foo2(firstParam, ...others) {
  for(var otherParam of others) {
    console.log(`other param: ${otherParam}`);
  }
}
foo2('a', 'b', 'c');

2.注意事项

不定参数只能作为最后一个参数，没值的时候是个空数组，非undefined

3.默认参数简单写法

function foo(param1="default value") {
  console.log(param1);
}
foo();
foo(undefined);

注意：传递undefined意味着没传值，所以参数会用默认值

4.默认参数自左向右求值

即你可以用左边的参数来作为右边参数求默认值的表达式的值

function foo(param1="default value", param2=param1) {
  console.log(param1, param2);
}
foo('daniel');

5.呼吁像禁掉IE一样禁掉arguments

既然不定参数和默认参数可以更加优雅地替换掉arguments，所以呼吁禁掉arguments这个怪物。
要实现这个目标，标准中制定了相应的限制：在使用不定参数或默认参数的函数中禁止使用arguments对象。（这个JS引擎还未实现，至少NodeJS 6的版本就没作限制，还是靠洁癖吧，实在没有用arguments的必要了）

---

第六章：解构

1.适用数据类型

1. 任何迭代器对象，如数组，Map，Set甚至Generator等

即解构的过程中会自动调用迭代器的next()方法取得值并赋给对应的变量，Generator的例子可能更好理解

• 数组例子：支持留空跳过，嵌套，不定参数

var [, v2, [v3], ...tail] = [1, 2, [3], 4, 5];
console.log(v2, v3, tail); // => 2 3 [4, 5]

• Generator例子

function* getNum() {
  var a = 0;
  while(true) {
    yield a++;
  }
}
var [v1, v2] = getNum();
console.log(v1, v2); // => 0 1

2. 普通对象：支持嵌套

var fooObj = {name: 'foo', tel: 8888888};
var {name: nameVal, tel: telVal} = fooObj;
var {name, tel} = fooObj; // 等价于var {name: name, tel: tel} = fooObj;

console.log(nameVal, telVal); // => foo 8888888
console.log(name, tel); // => foo 8888888

2.注意事项

正常：[a, b] = [1, 2];
报错：{a, b} = {a:1, b:2};

这是为什么呢？这是因为Javascript语法通知解析引擎将以 { 开始的语句作为块语句，而a, b不是有效的块语句

解决方法是加上括号，如({a, b} = {a:1, b:2})，这样就正常了。

但更好的做法还是老实地加上var或let或const吧

3.解构值非迭代器，非普通对象的情况

当使用数组赋值模式时，解构值必须实现迭代器，否则报错

var [name] = null; // null，undefined报错
var [name] = 1; // 原始类型报错，除了字符串
var [name] = 'Daniel'; // name => D 因为字符串被当成字符数组

当使用对象赋值模式时，解构值必须可转换成对象，否则报错

var {name} = null; // null，undefined报错。因为这两货无法转换成对象
var {name} = 1; // name => undefined。原始类型不报错，但因为没有对应的键嘛，所以值为undefined

4.适用场景

好像懂了，但用在哪些地方合适些呢？

• 函数参数定义

我们经常声明多个参数，如下代码。
这样对调用者不友好，因为他们要记住参数的使用顺序。而且对于前面的参数不想赋值时，还是得耐着性子按顺序给个undefined的值，是不是很不友好

function searchProducts(keyword, categoryId, pageNum, pageSize) {
  ...
}

那第一直觉是不是换个key-value的对象就行拉，好像是解决了上面的问题，如下代码。
但这里就很依赖于注释了，注释对不上，就悲剧了，调个方法想传个参数可能都得钻到源码里面去

/**
 * @param paramObj {keyword:, categoryId:, pageNum:, pageSize:}
 */
function searchProducts(paramObj) {
  ...
}

铛铛铛铛，解构一出手就知道有木有，上面的问题全不是问题了，看下面的代码，来，不要控制你激动的情绪，大声的哇~出来吧
这样无论是参数声明方式，调用者调用赋值时，都极其友好，加上默认值的支持，简直是，说不出话来了

function searchProducts({keyword, categoryId, pageNum = 1, pageSize = 12}) {
  ...   
}

• 实现多重值返回

以下代码看上去比使用临时变量的做法直观舒服多了

1. 以数组方式返回多值

function getMultiValues() {
  var result1 = {name: 'r1'};
  var result2 = 'r2';
  return [result1, result2];
}

// 解构做法
var [r1, r2] = getMultiValues();
console.log(r1, r2);

// 临时变量做法
var result = getMultiValues();
var r1 = result[0];
var r2 = result[1];
console.log(r1, r2);

2. 以对象方式返回多值

function getMultiValues() {
  var result1 = {name: 'r1'};
  var result2 = 'r2';
  return {r1: result1, r2: result2};
}

// 解构做法
var {r1, r2} = getMultiValues();
console.log(r1, r2);

// 临时变量做法
var result = getMultiValues();
var r1 = result.r1;
var r2 = result.r2;
console.log(r1, r2);

• 其它常用场景

导入CommonJS模块：

const {SourceMapConsumer, SourceNode} = require("source-map");

遍历迭代器对象：

for (var [key, value] of map) { ... }

---

这就是第五，六章的学习情况，接下来可继续看《读深入ES6记[四]》。

前面章节的学习情况请看：
《读深入ES6记[一]》
《读深入ES6记[二]》

--EOF--