函数的扩展

函数参数的默认值

• 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 foo(x, x, y) {
  // ...
}

// 报错
function foo(x, x, y = 1) {
  // ...
}

• 另外，一个容易忽略的地方是，参数默认值不是传值的，而是每次都重新计算默认值表达式的值。也就是说，参数默认值是惰性求值的。

let x = 99;
function foo(p = x + 1) {
  console.log(p);
}
foo() // 100
x = 100;
foo() // 101

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

function foo({x, y = 5}) {
  console.log(x, y);
}
foo({}) // undefined 5
foo({x: 1}) // 1 5
foo({x: 1, y: 2}) // 1 2
foo() // TypeError: Cannot read property 'x' of undefined

• 以上这种用法在传参时，无法省略参数，不需要传参的情况，也要传一个空对象，可以对起稍作修改

function foo({x, y = 5} = {}) {
  console.log(x, y);
}

foo() // undefined 5

• 通常情况下，我们将需要设置默认值的参数放在参数序列的尾部，因为放在头部将无法省略传参。

function f(x = 1, y) {
  return [x, y];
}
f() // [1, undefined]
f(2) // [2, undefined])
f(, 1) // 报错
f(undefined, 1) // [1, 1]

• 我们知道在JS中函数也是一个对象，且拥有一个属性----Length,用来返回函数参数的个数，但是当设置了参数默认值之后，这个属性将会失真，无法使用。

(function (a) {}).length // 1
(function (a = 5) {}).length // 0
(function (a, b, c = 5) {}).length // 2

• 一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域（context）。等到初始化结束，这个作用域就会消失。这种语法行为，在不设置参数默认值时，是不会出现的。

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

let x = 1;
function f(y = x) {
  let x = 2;
  console.log(y);
}
f() // 1

rest参数（剩余参数）

• 在ES6中引入了新参数rest，用法为（...value），它的作用是将剩余参数存入一个数组中

function add(...values) {
  let sum = 0;
  for (var val of values) {
    sum += val;
  }
  return sum;
}
add(2, 5, 3) // 10

• 需要注意的是该函数只能放在参数序列的最后一位，否则会报错

name属性

• 函数的name属性，返回该函数的函数名。
• ES6 对这个属性的行为做出了一些修改。如果将一个匿名函数赋值给一个变量，ES5 的name属性，会返回空字符串，而 ES6 的name属性会返回实际的函数名。

var f = function () {};
// ES5
f.name // ""
// ES6
f.name // "f"

• 若果是具名函数，即使把他赋值给其他变量，也会返回原来的名字。

箭头函数

• ES6允许使用箭头定义函数

var f = v => v;

等价于

var f = function(v) {
  return v;
};

• 如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。

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

var sum = (num1, num2) => num1 + num2;
// 等同于
var sum = function(num1, num2) {
  return num1 + num2;
};

• 由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号，否则会报错。

// 报错
let getTempItem = id => { id: id, name: "Temp" };

// 不报错
let getTempItem = id => ({ id: id, name: "Temp" });

• 如果箭头函数只有一行语句，且不需要返回值，可以采用下面的写法，就不用写大括号了。

let fn = () => void doesNotReturn();

• 箭头函数也可以与结构赋值一起使用

const full = ({ first, last }) => first + ' ' + last;
// 等同于
function full(person) {
  return person.first + ' ' + person.last;
}

• 箭头函数可以是函数变得更加美观，也可以简化回调函数
• 箭头函数虽然有诸多优点，但在使用时，还需注意以下几点
  • 函数体内的this是函数定义是所在的宿主对象，而不是调用时所在的对象
  • 不可以作为构造函数
  • 不可以使用arguments对象，可用rest实现相同功能
  • 不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

---

关于第一点尤其值得注意，我们知道的是在普通函数中它的this指针表示函数调用时，调用函数的那个对象，而在箭头函数中，该指针只与定义这个函数的对象有关，也就是说这个函数从定义完成时开始，他的this就是不可改变的，所以箭头函数也不可以使用apply()与call()方法

function foo() {
  setTimeout(() => {
    console.log('id:', this.id);
  }, 100);
}
var id = 21;
foo.call({ id: 42 });
//id:42

function Timer() {
  this.s1 = 0;
  this.s2 = 0;
  // 箭头函数
  setInterval(() => this.s1++, 1000);
  // 普通函数
  setInterval(function () {
    this.s2++;
  }, 1000);
}
var timer = new Timer();
setTimeout(() => console.log('s1: ', timer.s1), 3100);
setTimeout(() => console.log('s2: ', timer.s2), 3100);

• 箭头函数this的指向固定化并不是因为其内部机制绑定this不可改变，而是因为箭头函数根本没有this，导致内部代码快的this就是外部代码块的this，也正因如此，箭头函数无法作为构造函数
  举个栗子：

function foo() {
  return () => {
    return () => {
      return () => {
        console.log('id:', this.id);
      };
    };
  };
}
var f = foo.call({id: 1});
var t1 = f.call({id: 2})()(); // id: 1
var t2 = f().call({id: 3})(); // id: 1
var t3 = f()().call({id: 4}); // id: 1

• 上述结果也是因为箭头函数没有自己的this，导致call()然并卵，所以都指向最外层函数的this

---