K.Scott Allen对这件事有很好的评论。

基本上，它们在处理函数参数的方式上有所不同。

apply（）方法与call（）方法相同，只是apply（需要一个数组作为第二个参数。数组表示目标方法的参数。"

So:

// assuming you have f
function f(message) { ... }
f.call(receiver, "test");
f.apply(receiver, ["test"]);

从Function.pr原型.apply（）上的MDN文档中：

apply（）方法调用具有给定this值的函数作为数组（或类似数组的对象）提供的参数。语法fun.apply（thisArg，[argsArray]）

从Function.pr原型.call（）上的MDN文档中：

call（）方法调用具有给定this值和单独提供的参数的函数。语法fun.call（thisArg[，arg1[，arg2[，…]]]）

从JavaScript中的Function.apply和Function.call：

apply（）方法与call（）方法相同，只是apply（需要数组作为第二参数。数组表示的参数目标方法。

代码示例：

var doSomething=函数（）{var arr=[]；for（参数中的i）{if（this〔arguments〔i〕〕的类型！==“undefined”）{arr.push（this〔arguments〔i〕〕）；}}返回arr；}var输出=函数（位置，对象）{document.body.innerHTML+=“<h3>输出”+位置+“</h3>”+JSON.stringify（obj）+“\n<br>\n<br><hr>”；}输出（1，doSomething(“一”，“二”，“二”，“一”));输出（2，doSomething.apply（｛一：‘Steven’，二：‘Jane’｝[“一”，“二”，“二”，“一”]));输出（3，doSomething.call（｛一：‘Steven’，二：‘Jane’｝，“一”，“二”，“二”，“一”));

另请参见此Fiddle。

调用和应用都用于在执行函数时强制此值。唯一的区别是调用采用n+1个参数，其中1是this和“n”个参数。apply只接受两个参数，一个是this，另一个是argument数组。

我在apply-over-call中看到的优点是，我们可以轻松地将函数调用委托给其他函数，而无需付出太多努力；

function sayHello() {
  console.log(this, arguments);
}

function hello() {
  sayHello.apply(this, arguments);
}

var obj = {name: 'my name'}
hello.call(obj, 'some', 'arguments');

观察我们使用apply将hello委托给sayHello有多容易，但使用call很难做到这一点。

这些to方法之间的区别在于，如何传递参数。

“A代表数组，C代表逗号”是一个方便的助记符。

让我补充一点细节。

这两个调用几乎相等：

func.call(context, ...args); // pass an array as list with spread operator

func.apply(context, args);   // is same as using apply

只有一个微小的区别：

排列运算符。。。允许传递可迭代参数作为要调用的列表。apply只接受类似数组的参数。

因此，这些呼叫是相辅相成的。在我们期望可迭代的地方，调用工作，在我们期望类似数组的地方，应用工作。

对于既可迭代又类似于数组的对象，比如真正的数组，我们技术上可以使用它们中的任何一个，但apply可能会更快，因为大多数JavaScript引擎内部对其进行了更好的优化。

尽管call和apply实现了相同的功能，但我认为至少有一个地方不能使用call，只能使用apply。这是您希望支持继承并希望调用构造函数的时候。

这里有一个函数允许您创建类，它也支持通过扩展其他类来创建类。

function makeClass( properties ) {
    var ctor = properties['constructor'] || function(){}
    var Super = properties['extends'];
    var Class = function () {
                 // Here 'call' cannot work, only 'apply' can!!!
                 if(Super)
                    Super.apply(this,arguments);  
                 ctor.apply(this,arguments);
                }
     if(Super){
        Class.prototype = Object.create( Super.prototype );
        Class.prototype.constructor = Class;
     }
     Object.keys(properties).forEach( function(prop) {
           if(prop!=='constructor' && prop!=='extends')
            Class.prototype[prop] = properties[prop];
     });
   return Class; 
}

//Usage
var Car = makeClass({
             constructor: function(name){
                         this.name=name;
                        },
             yourName: function() {
                     return this.name;
                   }
          });
//We have a Car class now
 var carInstance=new Car('Fiat');
carInstance.youName();// ReturnsFiat

var SuperCar = makeClass({
               constructor: function(ignore,power){
                     this.power=power;
                  },
               extends:Car,
               yourPower: function() {
                    return this.power;
                  }
              });
//We have a SuperCar class now, which is subclass of Car
var superCar=new SuperCar('BMW xy',2.6);
superCar.yourName();//Returns BMW xy
superCar.yourPower();// Returns 2.6