Run results for: Class comp

Run details:

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1

Browser: Mobile Safari 15

Operating system: iOS 15.4.1

Device Platform: Mobile

Date tested: one year ago

Test name	Executions per second
Class.extends	2654344.0 Ops/sec
cls.prototype	1633014.5 Ops/sec

Script Preparation code:

/**
 *
 * <p>This script provides inheritance support and is inspired by base2 and Prototype</p>
 *
 * <p>The constructor is named <pre>init()</pre></p>
 *
 * <p>If a needs to override a method of a superclass, the overridden method can always be
 * called using</p>
 * <pre>this._super();</pre>
 *
 * <p>This is true for the constructor as well as for any other method.</p>
 *
 * @see http://etobi.de/blog/artikel/weiterlesen/vererbung-mit-javascript/
 *
 * @module util/Class
 */

/**
 * Base class which allows simple inheritance.
 *
 * @class module:util/Class~Class
 * @example
 * var MyClass = Class.extends({
 *     init : function(){
 *         // do some construction
 *     }
 * })
 *
 * // you can call the super class's method from within any method like this
 * ...
 *     myMethod : function(){
 *         // call 'myMethod' of super class
 *         this._super();
 *     }
 */
// Hack, because vars cannot be imported in DW, only functions
/**
 * @class
 */
function Class() {}

// eslint-disable-next-line wrap-iife
(function () {
    var initializing = false;
    var fnTest = /xyz/.test(function () {}) ? /\b_super\b/ : /.*/;

    // The base Class implementation (does nothing)
    // this.Class = function(){};

    /**
     * Create a new sub class
     * @param  {Object} prop An object defining the members of the sub class
     * @return {Object}      The sub class
     * @instance
     */
    Class.extends = function (prop) {
        var _super = this.prototype;

        // Instantiate a base class (but only create the instance,
        // don't run the init constructor)
        initializing = true;
        var prototype = new this();
        initializing = false;

        // Copy the properties over onto the new prototype
        var callback = function (name, fn) {
            return function () {
                var tmp = this._super;

                // Add a new ._super() method that is the same method
                // but on the super-class
                this._super = _super[name];

                // The method only need to be bound temporarily, so we
                // remove it when we're done executing
                var ret = fn.apply(this, arguments);
                this._super = tmp;

                return ret;
            };
        };
        // eslint-disable-next-line guard-for-in, no-restricted-syntax
        for (var name in prop) {
            // Check if we're overwriting an existing function
            prototype[name] =
                typeof prop[name] === 'function' && typeof _super[name] === 'function' && fnTest.test(prop[name]) ? callback(name, prop[name]) : prop[name];
        }

        /**
         * The dummy class constructor
         * @constructor
         */
        function Class() { // eslint-disable-line no-shadow
            // All construction is actually done in the init method
            if (!initializing && this.init) {
                this.init.apply(this, arguments);
            }
        }

        // Populate our constructed prototype object
        Class.prototype = prototype;

        // Enforce the constructor to be what we expect
        Class.constructor = Class;

        // And make this class extendable
        // eslint-disable-next-line no-caller
        Class.extends = arguments.callee;

        return Class;
    };
})();

Tests:

Class.extends
/** @type {module:util/Class~Class} */ //module.exports = Class; const cls = Class.extends({ /** * @constructor * @param {*} resource resource * @param {string } type type of resource, can be value|fabric (value is default) */ init: function () { }, doTest: function () { } }); const cls2 = cls.extends({ doTest: function () { } }); var obj = new cls2(); obj.doTest();
cls.prototype
function cls() { } cls.prototype = {}; cls.prototype.constructor = cls; cls.prototype.doTest= function() { } function cls2 () { cls.call(this); } cls2.prototype = Object.create(cls.prototype); cls2.prototype.constructor = cls; cls2.prototype.doTest= function() { } var obj = new cls(); obj.doTest();

Run results for: Class comp

Class.extends

cls.prototype