函数的扩展

---

参考文献

为函数参数设置默认值

function log(x, y = 'World') {
  console.log(x, y);
}

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

函数的 length 属性

回没有指定默认值的参数个数

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

其实，因为length属性的含义是，该函数预期传入的参数个数。如下。

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

作用域

ES6 明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。

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

在这里，函数f中的参数有一个作用域。

{
	let x;
	let y=x;
}

所以下面代码将报错。

function bar(x = y, y = 2) {
  return [x, y];
}
bar();

因为bar参数有一个作用域，在声明之前就使用这些变量，就会报错。

let x=y;
let y=2;

应用。

• 指定某一个参数不得省略，如果省略就抛出一个错误
  function foo(mustBeProvided = throwIfMissing()) {
  return mustBeProvided;
  }
  function foo(mustBeProvided = throwIfMissing()) {
  return mustBeProvided;
  }
• 指定一个参数是可以省略的
  function foo(optional = undefined) { ··· }

rest参数

ES6 引入 rest 参数（形式为…变量名），用于获取函数的多余参数，这样就不需要使用arguments对象了。rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中。(rest参数就是一个数组)

name 属性

返回函数的名字，是一个字符串

var f = function () {
    console.log("test");
};
// ES6
eval(f.name+'()');

• 如果将一个匿名函数赋值给一个变量，ES5 的name属性，会返回空字符串，而 ES6 的name属性会返回实际的函数名。
• 如果将一个具名函数赋值给一个变量，则 ES5 和 ES6 的name属性都返回这个具名函数原本的名字。

箭头函数

()=>{
return 1+2;
}

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

不适用场合!

• 第一个场合是定义对象的方法，且该方法内部包括this
  const cat = {
  lives: 9,
  jumps: () => {
  this.lives–;
  }
  }
• 需要动态this的时候，也不应使用箭头函数。
  var button = document.getElementById(‘press’);
  button.addEventListener(‘click’, () => {
  this.classList.toggle(‘on’);
  });

为什么这两个场合都不能使用。是因为箭头函数不可以使用arguments对象，该对象在函数体内不存在。argument对象都不存在，this就不用说了，因为this是作为argument的第一个参数的。

尾调用函数

尾调用（Tail Call）是函数式编程的一个重要概念，本身非常简单，一句话就能说清楚，就是指某个函数的最后一步是调用另一个函数。

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

尾调用由于是函数的最后一步操作，所以不需要保留外层函数的调用帧，因为调用位置、内部变量等信息都不会再用到了，只要直接用内层函数的调用帧，取代外层函数的调用帧就可以了。“尾调用优化”，节省内存。

注意！
只有不再用到外层函数的内部变量，内层函数的调用帧才会取代外层函数的调用帧，否则就无法进行“尾调用优化”。
function addOne(a){
var one = 1;
function inner(b){
return b + one;
}
return inner(a);
}
这就不会进行尾调用优化。

注意！！！
目前只有 Safari 浏览器支持尾调用优化，Chrome 和 Firefox 都不支持。并且ES6 的尾调用优化只在严格模式下开启，正常模式是无效的。

尾递归

如果尾调用自身，就称为尾递归。

栗子一：

function factorial(n, total) {
  if (n === 1) return total;
  return factorial(n - 1, n * total);
}
factorial(5, 1) // 120

栗子二：

function Fibonacci (n) {
  if ( n <= 1 ) {return 1};

  return Fibonacci(n - 1) + Fibonacci(n - 2);
}

Fibonacci(10) // 89
Fibonacci(100) // 超时
Fibonacci(500) // 超时

function Fibonacci2 (n , ac1 = 1 , ac2 = 1) {
  if( n <= 1 ) {return ac2};

  return Fibonacci2 (n - 1, ac2, ac1 + ac2);
}

Fibonacci2(100) // 573147844013817200000
Fibonacci2(1000) // 7.0330367711422765e+208
Fibonacci2(10000) // Infinity

递归函数的改写

上面尾递归的缺点就是不太直观，第一眼很难看出来，如栗子一中为什么还需要传第二个参数1

方法一是在尾递归函数之外，再提供一个正常形式的函数(涉及到函数柯里化，实现设定好一些参数)。

function tailFactorial(n, total) {
  if (n === 1) return total;
  return tailFactorial(n - 1, n * total);
}

function factorial(n) {
  return tailFactorial(n, 1);
}

factorial(5) // 120

/*柯里化的实现*/
function currying(fn, n) {
  return function (m) {
    return fn.call(this, m, n);
  };
}

function tailFactorial(n, total) {
  if (n === 1) return total;
  return tailFactorial(n - 1, n * total);
}

const factorial = currying(tailFactorial, 1);

factorial(5) // 120

第二种方法就简单多了，就是采用 ES6 的函数默认值

function factorial(n, total = 1) {
  if (n === 1) return total;
  return factorial(n - 1, n * total);
}

factorial(5) // 120