JS call、apply、bind、递归、闭包

call、apply、bind方法用来处理函数内部的this指向问题

在（https://www.cnblogs.com/qimuz/p/12740831.html）中介绍了用构造函数来创建对象，其中里面的this指的是谁调用this，它就指向谁。

function animal() {}
animal.prototype = {
    color: "grey",
    look: function() {
        console.log("It's color is " + this.color);
    }
};
var dog = new animal();
dog.look(); // It's color is grey
var cat = new animal();
cat.look(); // It's color is grey

上图所示，打印出来的都是“It's color is grey”，但是如果我们想改变cat的颜色，就要重新定义一个look方法，如果改变的多了，就会很麻烦。

call()

call() 方法调用一个函数, 它具有一个指定的 this 值和分别地提供的参数

fun.call(thisArg, arg1, arg2, ...)

• thisArg指的是在 fun 函数中指定的 this的值，是一个可选项

• arg1, arg2, …指定的参数列表，也是可选项

• 使用调用者提供的 this 值和参数调用该函数的返回值。若该方法没有返回值，则返回 undefined。

• call()允许为不同的对象分配和调用属于一个对象的函数/方法

• call()提供新的 this 值给当前调用的函数/方法。可以使用 call() 来实现继承：写一个方法，然后让另外一个新的对象来继承它,而不是在新对象中再写一次这个方法

  比如前面的例子可以改为：

  //使用 call() 方法调用函数并且指定上下文的 this
  function animal() {}
  animal.prototype = {
  color: "grey",
  look: function() {
  console.log("It's color is " + this.color);
  	}
  };
  
  var dog = new animal();
  cat = {
  color:"white"
  };
  dog.look.call(cat); 
  

  这样就更改了cat的颜色，输出为"It's color is white"

  除此之外，还可以通过调用父构造函数的call()方法来实现继承

  apply()

  这个方法与call方法类似，区别就是call方法里面接受的是参数，而apply方法接受的是数组

  fun.apply(thisArg, [argsArray]);
  

  1、将数组添加到另一个数组

  var arr = ["a", "b", "c"];
  var nums = [1, 2, 3];
  arr.push.apply(arr, nums);
  console.log(arr);  //返回["a", "b", "c", 1, 2, 3]
  

  结果为["a", "b", "c", 1, 2, 3]

  concat()、push()、apply()的区别：

  concat() 方法连接数组，不会改变原数组，而是创建一个新数组

  push() 是接受可变数量的参数的方式来添加元素

  apply() 则可以连接两个数组

  2、apply() 方法及内置函数

  var numbers = [3, 4, 6, 1, 9];
  var max = Math.max.apply(null, numbers);
  console.log(max);  //返回9
  

  bind()

  bind()方法创建一个新的函数（称为绑定函数），在调用时设置 this 关键字为提供的值。并在调用新函数时，将给定参数列表作为原函数的参数序列的前若干项。

  fun.bind(thisArg[, arg1[, arg2[, ...]]])
  

  thisArg指的是当绑定函数被调用时，该参数会作为原函数运行时的 this 指向。当使用 new 操作符调用绑定函数时，该参数无效。参数：arg1，arg2，…表示当目标函数被调用时，预先添加到绑定函数的参数列表中的参数。

  this.num = 6;
  var test = {
    num: 66,
    getNum: function() {
      return this.num;
    }
  };
  test.getNum(); // 返回 66
  var newTest = test.getNum;
  newTest(); // 返回 6
  // 创建一个新函数，将"this"绑定到 test 对象
  var bindgetNum = newTest.bind(test);
  bindgetNum(); // 返回 66
  

  递归

  在一个函数里，自己调用自己，就称为递归调用

  function fun(){
  			fun();
  			console.log('Hello World');
  			}//一定要写临界条件，不然程序无法结束并且会报错
  			fun();
  

  1、函数+变量

  例：求 1 到 100之间的整数相加的和

  function sum(n){
  		if(n==0){
  			return 0;
  		}else{
  			return n+sum(n-1);
  			}
  		}
  		var i = sum(100);
  		console.log(i);
  

  例：求10的阶乘

  function fun(n){
  		if(n==1){
  			return 1;
  		}else{
  			return n*fun(n-1);
  			}
  		}
  		var i = fun(10);
  		console.log(i);
  

  2、函数+函数

斐波拉契题
--从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，每个月的兔子对数为多少？

产量分析：1， 1， 2， 3， 5， 8， 13， 21 .......

第n个月的兔子总数 = 第n-1个月的兔子总数 + 第n-2个月的兔子总数

问题： 求任意月兔子的总数

function func( n )
{
    if (n == 0 || n == 1){
        return 1;
    }else{
        return func(n-1) + func(n-2);
    }
}

var i = func(11);
console.log(i);

闭包

指的是函数可以使用函数定义之外的变量，每当函数被创建，就会在函数生成时生成闭包

先来了解一下作用域这个概念：

作用域

作用域的值就是作用范围，也就是说一个变量或函数在什么地方可以使用，在什么地方不能使用

函数作用域

​ 指的是在函数内部声明的变量在这个函数体内是可见的

function test() {
  var num = 123;
  console.log(num); //123
  if (2 == 3) {
    var k = 5;
    for (var i = 0; i < 10; i++) {}
    console.log(i);
  }
  console.log(k); // 不会报错，显示 undefined
}
test();

全局作用域

指的就是在什么地方都能够访问到它

• 内层作用域可以访问外层作用域，反之不行。
• 整个代码结构中只有函数可以限定作用域。
• 如果当前作用规则中有名字了，就不考虑外面的同名变量。
• 作用域规则首先使用提升规则分析。

再来看闭包~

简单的闭包：全局变量

复杂的闭包：

function f1() {
		 var num=10;
		function f2() {
		console.log(num);
			}
		 //函数调用
		 f2();
			}
		f1(); //10

闭包可用来缓存数据~