ES6 函数扩展

函数默认值

ES6 与ES5 的区别

在ES6之前，不能直接为函数的指定默认值
ES5默认值方法

//方法一
function log(x, y) {
  y = y || 'value';
  console.log(x, y);
}
function log(x, y) {
  if (typeof y === 'undefined') {
  y = 'value';
}
  console.log(x, y);
}

es6

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

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

解构赋值自行领会

function fn1({x=0,y=1}={}){
    console.log(x,y)
};
function fn2({x,y}={x:0,y:1}){
    console.log(x,y)
}
fn1();
//0 1

fn2();
//0 1

fn1({x:2,y:2})
//2 2

fn2({x:2,y:2})
//2 2

fn1({x:2})
//2 1

fn2({x:2})
//2 undefined

fn1({})
//0 1

fn2({})
//undefined undefined

fn1({z:1})
//0 1

fn2({z:1})
//undefined undefined

默认参数省略

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

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

f() 
// [1, undefined]

f(2) 
// [2, undefined])

f(, 1) 
// 报错不执行

f(undefined, 1)
//[1,1] 

ps 默认参数尾部省略原则

函数的length 属性

(function(x,y){}).length
//2
(function(x,y=4){}).length
//1
(function(x=1,y=4){}).length
//0

作用域

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

y = function() { x = 2; }中的x 指向第一个参数x
foo函数中 对x 是否 var 决定 foo函数的x 指向是 参数x；或是独立的不属于一个作用域的x

rest参数

ES6 引入 rest 参数（形式为“…变量名”），用以获取函数的多余参数，这样就不需要使用arguments对象了

function val(...values){
    for(var val of values){
    console.log(val)
    }
}
val(1,4,6,7,8,9)
//1
//4
//6
//7
//8
//9

ps : rest参数之后不能再有其他参数了

扩展运算符

扩展运算符（spread）是三个点（…）。它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。

严格模式

从ES5开始，函数内部可以设定为严格模式。

function doSomething(a, b) {
  'use strict';
  // code
}

《ECMAScript 2016标准》做了一点修改，规定只要函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式，否则会报错。

箭头函数

var f = x => x;

上面的箭头函数等同于：

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

1. 不需要参数或需要多个参数情况

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

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

var f = () => 5;
var fn=(x,y)=>x+y
var fn1=(x,y)=>{return x+y}
var fn2=(x,y)=>({name:x,age:y})


var full = ({ first, last }) => first + ' ' + last;

// 等同于 person={first:'wewe',last:'ffd'}格式
function full(person) {
  return person.first + ' ' + person.last;
}

使用注意点

箭头函数有几个使用注意点。

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

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

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

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

上面四点中，第一点尤其值得注意。this对象的指向是可变的，但是在箭头函数中，它是固定的。

箭头函数ES5

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

// ES5
function foo() {
  var _this = this;

  setTimeout(function () {
    console.log('id:', _this.id);
  }, 100);
}

this 绑定

箭头函数可以绑定this对象，大大减少了显式绑定this对象的写法
ES7提出了“函数绑定”（function bind）运算符，用来取代call、apply、bind调用。虽然该语法还是ES7的一个提案，但是Babel转码器已经支持。

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

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

如果双冒号左边为空，右边是一个对象的方法，则等于将该方法绑定在该对象上面。

尾递归

在ES6中，只要使用尾递归，就不会发生栈溢出，相对节省内存。
ES6的尾调用优化只在严格模式下开启，正常模式是无效的。

这是因为在正常模式下，函数内部有两个变量，可以跟踪函数的调用栈。

func.arguments：返回调用时函数的参数。
func.caller：返回调用当前函数的那个函数。
严格模式下
尾调用即可

非严格模式下

function tco(f) {
  var value;
  var active = false;
  var accumulated = [];

  return function accumulator() {
    accumulated.push(arguments);
    if (!active) {
      active = true;
      while (accumulated.length) {
        value = f.apply(this, accumulated.shift());
      }
      active = false;
      return value;
    }
  };
}

var sum = tco(function(x, y) {
  if (y > 0) {
    return sum(x + 1, y - 1)
  }
  else {
    return x
  }
});

sum(1, 100000)