我们可以区分调用和应用方法，如下所示

CALL：单独提供参数的函数。若您知道要传递的参数或并没有要传递的变量，则可以使用call。

APPLY：调用以数组形式提供参数的函数。如果不知道要传递给函数的参数有多少，可以使用apply。

使用applyovercall有一个优点，我们不需要更改参数的数量，只需要更改传递的数组即可。

性能上没有太大差异。但我们可以说，调用比应用更快，因为数组需要在apply方法中求值。

我们可以区分调用和应用方法，如下所示

CALL：单独提供参数的函数。若您知道要传递的参数或并没有要传递的变量，则可以使用call。

APPLY：调用以数组形式提供参数的函数。如果不知道要传递给函数的参数有多少，可以使用apply。

使用applyovercall有一个优点，我们不需要更改参数的数量，只需要更改传递的数组即可。

性能上没有太大差异。但我们可以说，调用比应用更快，因为数组需要在apply方法中求值。

尽管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

虽然这是一个老话题，但我只是想指出，.call比.apply稍快。我不能告诉你确切的原因。

参见jsPerf，http://jsperf.com/test-call-vs-apply/3

[更新！]

Douglas Crockford简要提到了两者之间的差异，这可能有助于解释性能差异。。。http://youtu.be/ya4UHuXNygM?t=15m52s

Apply接受一个参数数组，而Call接受零个或多个单独的参数！啊哈！

.apply（此，[…]）

.调用（this，param1，param2，param3，param4…）

从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。

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

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

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

So:

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