JavaScript performance: Call vs Apply

Question

Is there a performance benefit in switching from func.apply(obj, params) to func.call(obj) when params is an empty array or null?

I mean, is calling func.call(obj) any faster than calling func.apply(obj, null)?

I'm mostly interested in performance under NodeJS 4.x.

This is for an algorithm that has to make a lot of such calls.

• Jared Smith: I realize that such an algorithm may make a lot of those calls, but its usually premature optimization to worry about such a trivial detail that bloats your code before profiling.
• vitaly-t: This is not being helpful. I'm asking for some real numbers for this sort of optimization, not to tell me how to do my own measurements or approach writing my algorithm.
• JJJ: The thing is, as with almost all micro-optimization, that the actual performance of a minuscule operation like this is dependent on the algorithm that uses it. You might well find that in isolated cases one is faster than the other, but in practice it's the other way around. There's no way to know for sure without trying it in the real use case.
• vitaly-t: In my case I have to rely heavily on this kind of calls. Anyhow, the answer by Magu is excellent, and the numbers speak for themselves!
• JJJ: Well the difference is 0.00000003 seconds per operation on my computer... but sure, if you have a million calls in a loop you'll save 30 milliseconds.

Answer 1

On this page there is a comparison. https://jsperf.com/call-apply-segu Call was faster on my machine.

Answer 2

Basically, they will do the same steps:

Function.prototype.apply (thisArg, argArray)

1. If IsCallable(func) is false, then throw a TypeError exception.
2. If argArray is null or undefined, then
   1. Return the result of calling the [[Call]] internal method of func, providing thisArg as the this value and an empty list of arguments.

Function.prototype.call (thisArg [ , arg1 [ , arg2, ... ] ] )

1. If IsCallable(func) is false, then throw a TypeError exception.
2. Let argList be an empty List.
3. If this method was called with more than one argument then in left to right order starting with arg1 append each argument as the last element of argList
4. Return the result of calling the [[Call]] internal method of func, providing thisArg as the this value and argList as the list of arguments.

So the difference, if any, should be implementation dependent, and negligible.

• vitaly-t: Thank you for the detailed explanation, but the answer by Magu gives the exact numbers, which is perfect for what I was looking for.

Answer 3

Ha, interesting: it looks like apply is slower than call. 8-)

 ~/tmp ω cat test.js 
function work(a, b, c) {
 // do some work
}
var a = [1, 2, 3];
for (var j = 0; j < 4; j++) {
 console.time('apply-ing');
 for (var i = 0; i < 1000000; i++) {
 work.apply(this, a);
 }
 console.timeEnd('apply-ing');
 console.time('call-ing');
 for (var i = 0; i < 1000000; i++) {
 work.call(this, 1, 2, 3);
 }
 console.timeEnd('call-ing');
}
 ~/tmp ω node test.js
apply-ing: 42ms
call-ing: 5ms
apply-ing: 40ms
call-ing: 5ms
apply-ing: 42ms
call-ing: 5ms
apply-ing: 39ms
call-ing: 6ms
 ~/tmp ω node --version
v4.1.2
 ~/tmp ω

• vitaly-t: According to the link published by Magu, apply is a lot slower than call.
• JerryCauser: it is an incorrect implementation. To justify everything better to use call like this work.call(this, ...a). And apply will win. Just only because apply here uses argument config as an argument. It's more useful for realworld