根本区别在于，call（）接受一个参数列表，而apply（）接受单个参数数组。

有时，一个对象借用另一个对象的函数是有用的，这意味着借用对象只需像执行自己的函数一样执行借出函数。

一个小代码示例：

var friend = {
    car: false,
    lendCar: function ( canLend ){
      this.car = canLend;
 }

}; 

var me = {
    car: false,
    gotCar: function(){
      return this.car === true;
  }
};

console.log(me.gotCar()); // false

friend.lendCar.call(me, true); 

console.log(me.gotCar()); // true

friend.lendCar.apply(me, [false]);

console.log(me.gotCar()); // false

这些方法对于为对象提供临时功能非常有用。

这里有一个小帖子，我在上面写道：

http://sizeableidea.com/call-versus-apply-javascript/

var obj1 = { which : "obj1" },
obj2 = { which : "obj2" };

function execute(arg1, arg2){
    console.log(this.which, arg1, arg2);
}

//using call
execute.call(obj1, "dan", "stanhope");
//output: obj1 dan stanhope

//using apply
execute.apply(obj2, ["dan", "stanhope"]);
//output: obj2 dan stanhope

//using old school
execute("dan", "stanhope");
//output: undefined "dan" "stanhope"

不同之处在于，call（）分别接受函数参数，而apply（）接受数组中的函数参数。

主要的区别是，使用调用，我们可以改变作用域并按正常方式传递参数，但apply允许您使用参数作为数组调用它（将它们作为数组传递）。但就它们在代码中的作用而言，它们非常相似。

虽然此函数的语法与apply（），基本区别是call（）接受一个参数list，而apply（）接受一个参数数组。

因此，正如您所看到的，这并没有太大的区别，但仍然有一些情况我们更喜欢使用call（）或apply（）。例如，查看下面的代码，使用apply方法从MDN中查找数组中最小和最大的数字：

// min/max number in an array
var numbers = [5, 6, 2, 3, 7];

// using Math.min/Math.max apply
var max = Math.max.apply(null, numbers); 
// This about equal to Math.max(numbers[0], ...)
// or Math.max(5, 6, ...)

var min = Math.min.apply(null, numbers)

所以主要的区别只是我们传递参数的方式：电话：

function.call(thisArg, arg1, arg2, ...);

应用：

function.apply(thisArg, [argsArray]);

以下摘自Michael Bolin的《结束：最终指南》。它可能看起来有点冗长，但它充满了很多洞察力。摘自“附录B.经常误解的JavaScript概念”：

调用函数时所指的内容

当调用foo.bar.baz（）形式的函数时，对象foo.bar被称为接收器。当函数被调用时，接收器被用作此函数的值：

var obj = {};
obj.value = 10;
/** @param {...number} additionalValues */
obj.addValues = function(additionalValues) {
  for (var i = 0; i < arguments.length; i++) {
    this.value += arguments[i];
  }
  return this.value;
};
// Evaluates to 30 because obj is used as the value for 'this' when
// obj.addValues() is called, so obj.value becomes 10 + 20.
obj.addValues(20);

如果在调用函数时没有显式接收器，则全局对象将成为接收器。如第47页“goog.global”中所述，当在web浏览器中执行JavaScript时，window是全局对象。这导致了一些令人惊讶的行为：

var f = obj.addValues;
// Evaluates to NaN because window is used as the value for 'this' when
// f() is called. Because and window.value is undefined, adding a number to
// it results in NaN.
f(20);
// This also has the unintentional side effect of adding a value to window:
alert(window.value); // Alerts NaN

尽管obj.addValues和f引用同一个函数，但它们在调用时的行为不同，因为每次调用中接收方的值都不同。因此，在调用引用此的函数时，务必确保在调用此函数时具有正确的值。要清楚的是，如果函数体中没有引用这一点，那么f（20）和obj.addValues（20）的行为将是相同的。

因为函数是JavaScript中的一流对象，所以它们可以有自己的方法。所有函数都有方法call（）和apply（），这使得在调用函数时可以重新定义接收器（即它所指的对象）。方法签名如下：

/**
* @param {*=} receiver to substitute for 'this'
* @param {...} parameters to use as arguments to the function
*/
Function.prototype.call;
/**
* @param {*=} receiver to substitute for 'this'
* @param {Array} parameters to use as arguments to the function
*/
Function.prototype.apply;

请注意，call（）和apply（）之间的唯一区别是call（）将函数参数作为单个参数接收，而apply（（）将它们作为单个数组接收：

// When f is called with obj as its receiver, it behaves the same as calling
// obj.addValues(). Both of the following increase obj.value by 60:
f.call(obj, 10, 20, 30);
f.apply(obj, [10, 20, 30]);

以下调用是等效的，因为f和obj.addValues引用同一个函数：

obj.addValues.call(obj, 10, 20, 30);
obj.addValues.apply(obj, [10, 20, 30]);

但是，由于call（）和apply（）在未指定接收方参数时都不使用自身接收方的值来替换接收方参数，因此以下操作将不起作用：

// Both statements evaluate to NaN
obj.addValues.call(undefined, 10, 20, 30);
obj.addValues.apply(undefined, [10, 20, 30]);

调用函数时，this的值不能为null或未定义。当向call（）或apply（）提供null或undefined作为接收方时，将使用全局对象作为接收方的值。因此，前面的代码具有相同的不良副作用，即向全局对象添加一个名为value的属性。

将函数视为不知道其所分配的变量可能会有所帮助。这有助于强化这样一种观念，即当调用函数时，而不是定义函数时，它的值将被绑定。

提取结束。