ES6函数扩展

参数指定默认值

//方式一
//问题:对应的布尔值为false，则该赋值不起作用
function log(x, y) {
  y = y || 'World';
  console.log(x, y);
}

log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello World

//方式二
function log(x, y) {
	if (typeof y === 'undefined') {
	  y = 'World';
	}
  console.log(x, y);
}

log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello World

//es6的写法
function log(x, y = 'World') {
  console.log(x, y);
}

log('Hello') // Hello World
log('Hello', 'China') // Hello China
log('Hello', '') // Hello

参数变量是默认声明的，所以不能用let或const再次声明

function foo(x = 5) {
  let x = 1; // error
  const x = 2; // error
}

与解构赋值默认值结合使用

// 写法一
function m1({x = 0, y = 0} = {}) {
  return [x, y];
}

// 写法二
function m2({x, y} = { x: 0, y: 0 }) {
  return [x, y];
}

// 函数没有参数的情况
m1() // [0, 0]
m2() // [0, 0]

// x 和 y 都有值的情况
m1({x: 3, y: 8}) // [3, 8]
m2({x: 3, y: 8}) // [3, 8]

// x 有值，y 无值的情况
m1({x: 3}) // [3, 0]
m2({x: 3}) // [3, undefined]

// x 和 y 都无值的情况
m1({}) // [0, 0];
m2({}) // [undefined, undefined]

m1({z: 3}) // [0, 0]
m2({z: 3}) // [undefined, undefined]

参数默认值的位置

function f(x = 1, y) {
  return [x, y];
}

f(1, ,2) // 报错
//有默认值的参数都不是尾参数。需要显式输入undefined。

函数的 length 属性

返回没有指定默认值的参数个数
如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了。

(function(...args) {}).length // 0
(function (a = 0, b, c) {}).length // 0

作用域

参数会形成一个单独的作用域（context）。等到初始化结束，这个作用域就会消失。

var x = 1;

function foo(x = x) {
  // ...
}
foo() // ReferenceError: x is not defined 
//数x = x形成一个单独作用域。实际执行的是let x = x，由于暂时性死区的原因，这行代码会报错”x 未定义“。

例子

var x = 1;
function foo(x, y = function() { x = 2; }) {
  var x = 3;
  y();
  console.log(x);
}

foo() // 3
x // 1

var x = 1;
function foo(x, y = function() { x = 2; }) {
  x = 3;
  y();
  console.log(x);
}

foo() // 2
x // 1

rest

数之后不能再有其他参数（即只能是最后一个参数），否则会报错。

// 报错
function f(a, ...b, c) {
  // ...
}

严格模式

函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式

// 默认值 报错 
function doSomething(a, b = a) {
  'use strict';
  // code
}

// 解构赋值 报错
const doSomething = function ({a, b}) {
  'use strict';
  // code
};

// 扩展运算符 报错
const doSomething = (...a) => {
  'use strict';
  // code
};

const obj = {
  // 报错
  doSomething({a, b}) {
    'use strict';
    // code
  }
};

只有从函数体之中，才能知道参数是否应该以严格模式执行，但是参数却应该先于函数体执行。

规避这种限制

第一种是设定全局性的严格模式

'use strict';

function doSomething(a, b = a) {
  // code
}

第二种是把函数包在一个无参数的立即执行函数里面。

const doSomething = (function () {
  'use strict';
  return function(value = 42) {
    return value;
  };
}());

箭头函数

var f = v => v;

// 等同于
var f = function (v) {
  return v;
};

注意点

（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
（2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

尾调用

指某个函数的最后一步是调用另一个函数。
尾调用，可以做到每次执行时，调用帧只有一项，这将大大节省内存。

function f(x){
  return g(x);
}