函数的调用

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

function Point(x = 0, y = 0) {
  this.x = x;
  this.y = y;
}
const p = new Point();
p // { x: 0, y: 0 }

与解构赋值默认值结合使用：在参数是解构赋值时应该设置参数默认值，解决函数调用不提供参数报错问题

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就不会生成导致报错
//通过提供函数参数的默认值，就可以避免这种报错情况。
function foo({x, y = 5} = {}) { console.log(x, y);}
foo() // undefined 5

 

// 写法一
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, 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]
function foo(x = 5, y = 6) {
  console.log(x, y);
}
foo(undefined, null)
// 5 null

函数的length属性：指定了默认值以后，函数的length属性，将返回没有指定默认值的参数个数。也就是说，指定了默认值后，属性length将失真。如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了。此外，也不包括 rest 参数

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

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

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

作用域：一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域。关键：就近原则

var x = 1;

function f(x, y = x) {//在这个作用域中，默认值变量x指向第一个参数x而非全局变量x
  console.log(y);
}

f(2) // 2

let x = 1;

function f(y = x) {//在这个作用域中，变量x本身没有定义，故指向全局变量x
  let x = 2;
  console.log(y);
}

f() // 1

//如果参数的默认值是一个函数，该函数的作用域也遵守这个规则
let foo = 'outer';
function bar(func = () => foo) {
  let foo = 'inner';
  console.log(func());
}

bar(); // outer

var x = 1;
function foo(x, y = function() { x = 2; }) {//y的默认值是一个匿名函数，变量x和第一个参数x是同一作用域
  var x = 3;//foo函数内部用var声明了变量，当前变量x和第一个参数x不是同一个作用域
  y();
  console.log(x);
}

foo() // 3   //就近原则，输出3
x // 1  //外部全局变量x不受局部影响

var x = 1;
function foo(x, y = function() { x = 2; }) {
  x = 3;//当前变量x和第一个参数x是同一个作用域
  y();
  console.log(x);
}

foo() // 2   //就近原则执行完y（）后，输出2   
x // 1   //外部全局变量x不受局部影响

rest参数（形式为：...参数名）：用于获取函数的多余参数，这样就不需要使用arguments对象了。rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中。注意，rest 参数之后不能再有其他参数（即只能是最后一个参数），否则会报错。

 

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

var a = [];
push(a, 1, 2, 3);//利用 rest 参数，可以向该函数传入任意数目的参数

严格模式：只要函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式，否则会报错。两种方法可以规避这种限制：1.设置全局性的严格模式  2.把函数包在一个无参数的立即执行函数里面

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

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

// 报错
const doSomething = (...a) => {
  'use strict';
  // code
};

'use strict';

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

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

箭头函数：1. 函数体内的this对象就是定义时所在的对象，是固定的。 2. 不可以当作构造函数即不能使用new命令。 3.不可使用arguments对象。 4.不可使用yield命令。箭头函数没有自己的this，所以就不能使用call()、apply()、bind()方法去改变this的指向

 

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);
// s1: 3
// s2: 0

function foo() {//该段代码只有一个this，就是foo函数的this
  return () => {//所有的内层函数都是箭头函数，都没有自己的this,当前箭头函数的this都是foo函数的this
    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,当前箭头函数的this都是foo函数的this
    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

(function() {
  return [
    (() => this.x).bind({ x: 'inner' })()//bind方法无效，内部this指向外部this
  ];
}).call({ x: 'outer' });
// ['outer']

尾调用优化：函数式编程的一个重要概念，指某个函数的最后一步操作(不一定就是函数尾部)是调用另一个函数。只保留内层函数的调用帧。意义：如果所有函数都是尾调用，那么完全可以做到每次执行时，调用帧只有一项，这将大大节省内存。

 

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

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

// 情况一
function f(x){
  let y = g(x);//调用g之后还有赋值操作
  return y;
}

// 情况二
function f(x){
  return g(x) + 1;//调用g之后还有赋值操作}

// 情况三function f(x){  g(x);}//等同于function f(x){g(x);return undefined}

只有不再用到外层函数的内部变量，内层函数的调用帧才会取代外层函数的调用帧，否则就无法进行“尾调用优化”。

function addOne(a){
  var one = 1;
  function inner(b){//内层函数inner用到了外层函数addOne的内部变量one，故不会进行尾调用优化
    return b + one;
  }
  return inner(a);
}尾调用优化
    return b + one;
  }
  return inner(a);
}

 

尾递归：函数调用自身，称为递归。如果尾调用自身，就称为尾递归。递归非常耗费内存，因为需要同时保存成千上百个调用帧，很容易发生“栈溢出”错误。但对于尾递归来说，由于只存在一个调用帧，所以永远不会发生“栈溢出”错误。

 

 

function Fibonacci2 (n , ac1 = 1 , ac2 = 1) {//尾递归优化过的 Fibonacci 数列实现如下
  if( n <= 1 ) {return ac2};

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

Fibonacci2(100) // 573147844013817200000
Fibonacci2(1000) // 7.0330367711422765e+208
Fibonacci2(10000) // Infinity尾递归优化过的 Fibonacci 数列实现如下
  if( n <= 1 ) {return ac2};

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

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