ES6 函数的拓展笔记

1.函数参数的默认值

　　（1）ES6允许为函数的参数设置默认值，即直接写在参数定义的后面。

　　function log( x, y = 'world' ) {  xxx }

　　function Point( x = 0, y = 0) { xxx }

　　参数默认值不是传值的，而是每次都重新计算默认值表达式的值。也就是说，参数默认值是惰性求值的。

　　（2）与解构赋值默认值结合使用

　　　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

　　　表明，只当函数foo的参数是一个对象是，变量x和y才会通过解构赋值生成。如果foo调用时没有提供参数，变量x和y就不会生成，从而报错。通过提供函数参数的默认值，就可以避免这种情况。

　　将上段代码参数部分更改为：function foo( { x, y=5 } = { } ){ xxx };   foo() // undefined, 5

　　表明，如果没有提供参数，函数foo的参数默认为一个空对象。

　　（3）参数默认值的位置

　　　通常情况下，定义了默认值的参数，应该是函数的尾参数。因为这样比较容易看出来，到底省略了那些参数。如果非尾参数设置默认值，实际上这个参数是没法省略的。

　　

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

f() // [1, undefined]
f(2) // [2, undefined])
f(, 1) // 报错
f(undefined, 1) // [1, 1]

// 例二
function f(x, y = 5, z) {
  return [x, y, z];
}

f() // [undefined, 5, undefined]
f(1) // [1, 5, undefined]
f(1, ,2) // 报错
f(1, undefined, 2) // [1, 5, 2]

　　　　上面代码中，有默认值的参数都不是尾参数。这时，无法只省略该参数，而不省略它后面的参数，除非显式输入undefined。

　　　　如果传入undefined，将触发该参数等于默认值，null则没有这个效果。

　　（4）函数的Length属性

　　指定了默认值后，函数的length属性，将返回没有指定默认值的参数个数。也就是说，指定了默认值后，Length属性将失真。

　　

　　(function( a ) { }).length  // 1

　　(function(a = 5) { }).length // 0 

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

　　(function(...args) {}).length // 0

如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了。

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

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

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

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

　　　　默认值变量x 指向第一个参数x，而不是全局变量x，所以输出2.

let x = 1;

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

f() // 1

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

function push(array,..items){
   items.forEach(function(item){
        array.push(item);
         console.log(item);  
   });
}

var a = [];
push(a,1,2,3);

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

　　比如：function f( a, ..b, c) {  xxx } // 报错

　　函数的Length，不包括rest参数。

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

3.严格模式
　从es5开始，函数内部可以设点为严格模式，es2016做了一点修改，规定只要函数参数使用了默认值，解构赋值，或者扩展运算符，那么函数内部就不能显示设定为严格模式，否则就会报错。
　　两种方法可以规避这种限制。第一种是设定全局性的严格模式，这是合法的

'use strict';

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

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

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

4.name属性
　　返回该函数的函数名。
　　function foo(){}   foo.name // 'foo'
　　需要注意的是，ES6 对这个属性的行为做出了一些修改。如果将一个匿名函数赋值给一个变量，ES5 的name属性，会返回空字符串，而 ES6 的name属性会返回实际的函数名。

var f = function () {};

// ES5
f.name // ""

// ES6
f.name // "f"

如果将一个具名函数赋值给一个变量，则 ES5 和 ES6 的name属性都返回这个具名函数原本的名字。

const bar = function baz() {};

// ES5
bar.name // "baz"

// ES6
bar.name // "baz"

bind返回的函数，name属性值会加上bound前缀。

function foo() {};
foo.bind({}).name // "bound foo"

(function(){}).bind({}).name // "bound "

5. 箭头函数
　　ES6 允许使用“箭头”（=>）定义函数。
　　如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。

var f = () => 5;
var sum = (num1, num2) => num1 + num2;

如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回。

var sum = (num1, num2) => { return num1 + num2; }

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

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

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

箭头函数使用注意点

　　（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。

　　（2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。

　　（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。

　　（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

6.双冒号运算符
　　函数绑定运算符是并排的两个双冒号:: ,双冒号左边是一个对象，右边是一个函数。该运算符会自动将左边的对象，作为上下文环境（即this环境），绑定到右边的函数上面。
　　

foo::bar;
// 等同于
bar.bind(foo);

foo::bar(...arguments);
// 等同于
bar.apply(foo, arguments);

const hasOwnProperty = Object.prototype.hasOwnProperty;
function hasOwn(obj, key) {
  return obj::hasOwnProperty(key);
}

7.尾调用优化
　　尾调用是函数式编程的一个重要概念，指某个函数的最后一步是调用另一个函数。
　　function f(x){ return g(x);  } ，这段代码中，函数f的最后一步（最后一步操作）是调用函数g，这就叫尾调用。

以下三种情况，都不属于尾调用。

// 情况一
function f(x){
  let y = g(x);
  return y;
}

// 情况二
function f(x){
  return g(x) + 1;
}

// 情况三
function f(x){
  g(x);
}

尾调用优化
　　1 尾调用之所以和其它不同，在于它的特殊调用位置。
　　2 函数调用会在内存形成一个“调用记录”，又称“调用帧”，保存调用位置和内部变量等信息。所有的调用帧，就形成一个“调用栈”。
　　3“尾调用优化”（Tail call optimization），即只保留内层函数的调用帧。如果所有函数都是尾调用，那么完全可以做到每次执行时，调用帧只有一项，这将大大节省内存。这就是“尾调用优化”的意义。
注意，只有不再用到外层函数的内部变量，内层函数的调用帧才会取代外层函数的调用帧，否则就无法进行“尾调用优化”。

function addOne(a){
  var one = 1;
  function inner(b){
    return b + one;
  }
  return inner(a);
}

上面的函数不会进行尾调用优化，因为内层函数inner用到了外层函数addOne的内部变量one。

尾递归
　　函数调用自身，称为递归。如果尾调用自身，就称为尾递归。
　　递归非常耗费内存，因为需要同时保存成千上百个调用帧，很容易发生“栈溢出”错误（stack overflow）。但对于尾递归来说，由于只存在一个调用帧，所以永远不会发生“栈溢出”错误。
　　
递归函数的改写
　　尾递归的实现，往往需要改写递归函数，确保最后一步只调用自身。做到这一点的方法，就是把所有用到的内部变量改写成函数的参数
　　函数式编程有一个概念，叫做柯里化（currying），意思是将多参数的函数转换成单参数的形式。这里也可以使用柯里化。

　　总结一下，递归本质上是一种循环操作。纯粹的函数式编程语言没有循环操作命令，所有的循环都用递归实现，这就是为什么尾递归对这些语言极其重要。对于其他支持“尾调用优化”的语言（比如 Lua，ES6），只需要知道循环可以用递归代替，而一旦使用递归，就最好使用尾递归。

严格模式
　　ES6 的尾调用优化只在严格模式下开启，正常模式是无效的。
　　这是因为在正常模式下，函数内部有两个变量，可以跟踪函数的调用栈。

func.arguments：返回调用时函数的参数。
func.caller：返回调用当前函数的那个函数。

8. 函数参数的尾逗号
　　es2017允许函数的最后一个参数有尾逗号（trailing comma)。

function clownsEverywhere(
  param1,
  param2,
) { /* ... */ }

clownsEverywhere(
  'foo',
  'bar',
);