function calls: direct vs apply vs call vs bind

JavaScript performance comparison

Revision 18 of this test case created by Ger Hobbelt

Info

Testing various ways to invoke a function, including several ways to manipulate its 'this'.

Preparation code

 
<script>
Benchmark.prototype.setup = function() {
    var f = function() {
      return this;
    };
   
    var that = {
      f: f
    };
   
    var bound = f.bind(that);
   
    var wrappedCall = function() {
      f.call(that);
    };
   
    var slice = Array.prototype.slice;
    Function.prototype.bind2 = function(_this) {
      var _self = this;
      var args = slice.call(arguments, 1);
      if (args.length === 0) {
        return function() {
          if (arguments.length === 0)
            return _self.call(_this);
          else if (arguments.length > 0)
            return _self.apply(_this, args);
        }
      }
   
      return function() {
        if (arguments.length === 0) return _self.apply(_this, args);
   
        var a2 = args.contact(slice.call(arguments));
        return _self.apply(_this, a2);
      }
    }
   
    var bound2 = f.bind2(that);
   
    var name = 'f';
};
</script>

Test runner

Warning! For accurate results, please disable Firebug before running the tests. (Why?)

Java applet disabled.

Testing in unknown unknown
Test Ops/sec
direct
that.f();
pending…
apply
f.apply(that);
pending…
call
f.call(that);
pending…
bind
bound();
pending…
bind2
bound2();
pending…
by string
that['f']();
pending…
by string (indirect)
that[name]();
pending…
direct (local)
f();
pending…
Wrapped Call
wrappedCall();
pending…
call by string
that['f'].call(that);
pending…
bind inline
f.bind(that)();
pending…

Compare results of other browsers

Revisions

You can edit these tests or add even more tests to this page by appending /edit to the URL. Here’s a list of current revisions for this page:

1 comment

Ger Hobbelt (revision owner) commented :

turns out the fastest invoke which can manipulate the 'this' is .call, at least for Chrome Canary v33. jison is using .bind() inline in one spot and that is lethargically slow, also compared to .call()

Add a comment