Backbone Vs John Resig's Simple JavaScript Inheritance

JavaScript performance comparison

Revision 15 of this test case created

Info

This is a performance test between Backbone models and John Resig's Simple JavaScript Inheritance script.

Preparation code

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js">
</script>
<script src="//cdnjs.cloudflare.com/ajax/libs/underscore.js/1.4.4/underscore-min.js">
</script>
<script src="//cdnjs.cloudflare.com/ajax/libs/backbone.js/1.0.0/backbone-min.js">
</script>
<script type="text/javascript">
  /* Simple JavaScript Inheritance
 * By John Resig http://ejohn.org/
 * MIT Licensed.
 */

  // Inspired by base2 and Prototype
  (function() {
    var a = false,
        b = /xyz/.test(function() {
        xyz
      }) ? /\b_super\b/ : /.*/;
    this.Class = function() {};
    Class.extend = function(g) {
      var f = this.prototype;
      a = true;
      var e = new this();
      a = false;
      for (var d in g) {
        e[d] = typeof g[d] == "function" && typeof f[d] == "function" && b.test(g[d]) ? (function(h, i) {
          return function() {
            var k = this._super;
            this._super = f[h];
            var j = i.apply(this, arguments);
            this._super = k;
            return j
          }
        })(d, g[d]) : g[d]
      }
      function c() {
        if (!a && this.init) {
          this.init.apply(this, arguments)
        }
      }
      c.prototype = e;
      c.prototype.constructor = c;
      c.extend = arguments.callee;
      return c
    }
  })();
</script>
<script>
(function () {
var slice = Array.prototype.slice;
 
function copy () {
        var dest = arguments[0],
                src = slice.call(arguments, 1);
 
        for (var i = 0; i < src.length; i++) {
                for (var key in src[i]) {
                        dest[key] = src[i][key];
                }
        }
}

function bind (fn, ctx) {
        return function () {
                return fn.apply(ctx, arguments);
        }
}

function isFunction (obj) {
        var checkType = {};
        return obj && checkType.toString.call(obj) === '[object Function]';
}

function Module () {
        this.bindMethods();

        if (this.parent && this.parent.init && isFunction (this.parent.init)) {
                this.parent.init.apply(this, arguments);
        }
       
        if (this.init && isFunction (this.init)) {
                this.init.apply(this, arguments);
        }
}

Module.extend = function (instance, static) {
        var tmp = this;
        var obj = function () {
                return tmp.apply(this, arguments);
        }

        // Copy the instance methods
        copy(obj.prototype, this.prototype, instance);
       
        // Copy the static methods
        copy(obj, this, static);
       
        // Set up the "parent" object
        obj.prototype.parent = this.prototype;
               
        return obj;
}

Module.prototype.bindMethods = function () {
        for (var key in this) {
                if (isFunction (this[key])) {
                        this[key] = bind(this[key], this);
                }
        }
}

window.Module = Module;
}());
<script>
Benchmark.prototype.setup = function() {
    window.array = [];
   
    myModel = Backbone.Model.extend({
      defaults: {
        foo: "bar",
        fizz: "buzz",
        a: 1,
        b: 2
      }
    });
   
    ResigsClass = Class.extend({
   
      foo: "bar",
      fizz: "buzz",
      a: 1,
      b: 2
   
    });
   
    someModule = Module.extend({
      foo: 'bar',
      fizz: 'buzz',
      a: 1,
      b: 2
    });
};
</script>

Preparation code output