每个函数都包含两个非继承而来的方法：apply()和call()。
call与apply都属于Function.prototype的一个方法，所以每个function实例都有call、apply属性；call() 方法使用一个指定的 this 值和单独给出的一个或多个参数来调用一个函数。
注意：该方法的语法和作用与 apply() 方法类似，只有一个区别，就是 call() 方法接受的是一个参数列表，而 apply() 方法接受的是一个包含多个参数的数组。
————MDN

以上描述略显生硬，通俗的来讲，就是使用call和apply可以在调用方法时改变其的执行环境

function fn(){ console.log(1) }
fn() // 1
fn.call() // 1 

因为call的第一个参数是来指定函数的运行环境的，在未指定，或者指定为“null，undefined”等情况下，认为是window环境,所以如下，如果指定了，那么this就指向你所指定的对象

function fn(){
    console.log(this,'\n', arguments)
}
var obj = {name: 'LLLLL'}
fn.call(); 
fn.call(obj)

运行结果如下：

image.png

image.png

看以上的代码，调用函数可以使用“fn.call()”,它在不传this的情况下作用和直接fn()是一样的，在执行function fn(){console.log(this)}时，打印的也是window，因此，对于this的理解，使用fn.call()这种方式更为明了一些。

可是this看着确实挺别扭，但为啥又需要this呢？我们来模拟下没有this的情况

var language = {
    name: 'javascript',
    sayName: function(lan) {
        console.log('I am '+ lan.name)
    },
    sayWord: function(lan, word){
        console.log(lan.name + ' said: '+word)
    }
}
// 我们要拿到language的name属性，必须像下边这样
language.sayName(language)  //  "I am javascript"
language.sayWord(language, 'call并不难理解')   // "javascript said: call并不难理解"

// 可是这样看着太繁琐了，你甚至会觉得sayName和sayWord方法定义在外边更合适一点
// 所以，而this的作用在这种情况下就能体现出来了,对象可以改成这样：
var language = {
    name: 'javascript',
    sayName: function() {
        console.log('I am '+ this.name)
    },
    sayWord: function(word){
        console.log(this.name + ' said: '+word)
    }
}
// 调用方式改为：
language.sayName.call(language)
language.sayWord.call('call并不难理解')
//港真，这更恶心了。。。 但是先贤为我们准备了语法糖。
language.sayName()
language.sayWord('call并不难理解') // js解析器会查找语句中是否有call或者apply或者bind之类的关键字，如果有，那么就是用指定的this；如果没有，那么将“.”前边的内容视为this

// 现在像如下语句
language.sayName.call({name: 'css'})  //解析器发现有call，那么，执行环境切换为{name: 'css'}，输出“ I am css”

至于apply，只是它除了this之外的参数可以传一个对象，而call就只能将参数一个一个传递，其他地方，这俩基本一样
call,apply的第一个参数，一定一定是this，后边的就是arguments了

2020-1-4 更新
今天看到这样一个面试题

function fn1(){
  console.log("fn1")
}
function fn2(){
  console.log("fn2")
 }
fn2.call.call.call.call(fn1)

我的第一反应是打印出“fn2”，概括成一句话就是执行fn2并且以fn1位上下文环境。可是运行的结果却是fn1，我人傻了。接下来，我们尝试来自己写一个call

function fn(){
  console.log(this)
}
fn.call(1) // Number {1}
// 人话就是将1当做this，执行fn，若果参数是普通值（除undefined和null），那么将它转化为对象形式
//等同于
let num1 = new Object(1)
num1.fn = fn;
num1.fn() //使用完后需将这个属性删除

基于以上已知知识，我们来写call

Function.prototype.call1 = function(thisValue, ...args) {
  //thisValue是要指定的this
  // call1是通过  function实例来调用的，因此在这个函数内部，this就是函数实例
  // 其实要达到的效果就是  thisValue.this(); 这里有疑惑的同学看上一段代码的例子
  // thisValue必须是对象，不是的话，将它转化成对象
  if (
    typeof thisValue !== "object" &&
    typeof thisValue != undefined &&
    thisValue !== null
  ) {
    thisValue = new Object(thisValue);
  }
  let fn = this;
  thisValue.f = fn;
  thisValue.f(...args);
  delete thisValue.f;
};

因为fn.call还是一个函数，所以，简化一下上边的fn2.call.call.call.call(fn1)，相当于call方法.call(fn1)
此时fn1就是this(直接用this字面量替换上边我们自己完成的call1方法中的this，也就是thisValue.f),所以结果就是执行thisValue.f,也就是fn1
总结起来，一句话,当call的数量大于1时，就是执行call中的方法