John Resig's JavaScript inheritance implementation: why `initializing`?

Question

I am studying John Resig's OOO implementations in JavaScript. The code is like:

(function(){
    var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
    this.Class = function(){};
    Class.extend = function(prop) {
        var _super = this.prototype;
        initializing = true;
        var prototype = new this();
        initializing = false;
        for (var name in prop) {
            // ...
        }
        function Class() {
            if ( !initializing && this.init )
                this.init.apply(this, arguments);
        }
        Class.prototype = prototype;
        Class.prototype.constructor = Class;
        Class.extend = arguments.callee;
        return Class;
    };
})();

The problem is: why we use initializing here?

I guess that the statement var prototype = new this(); may be async. So when the new ChildClass() is called, the initialization (assignment of the properties to the prototype of ChildClass) may not have been done. But I am pretty not sure whether it is correct or not.

After searching around, I still cannot understand the purpose of using the variable initializing. I found this article has some explanations, but I could not understand: Understanding John Resig's 'Simple JavaScript Inheritance'

Could anybody explain the purpose of it in detailed? Say, give some scenarios where the code fails without the initializing?

Update

Problem solved.

I composed an article to record down the details: Understanding John Resig’s ‘Simple JavaScript Inheritance’

Natural Lam · Accepted Answer · 2015-10-20 06:16:11Z

1

function Class() {
    if ( !initializing && this.init )
        this.init.apply(this, arguments);
}

when initializing is true then you are 'setting up' the Class object itself, so you don't want to call the init instance method defined by each concrete class.

You may do something like this: var RedCoupe = Class.extend({ init: function () { this._type = 'coupe'; this._color = 'red'; }); var myCar = new RedCoupe();

In this case, you want new RedCoupe(); to call init, but not when defiing var RedCoupe = Class.extend({ ... });, does it make sense?

edited Oct 20, 2015 at 6:16

answered Oct 20, 2015 at 5:56

Natural Lam

7424 silver badges13 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

Joy Over a year ago

Thanks. Normally, when Class.extend is executed, the initializing is set to true, then the new, then set to false. If the new is always sync, when it reaches if ( !initializing && this.init ), the value is initializing is always false. If it is always false, why use it?

Natural Lam Over a year ago

yes, sorry I've kinda said the opposite. so when initializing is true, it means "setting up" the Class object, which new this() is assigned to the prototype of the Class, so we shouldn't call the init instance method.

Natural Lam Over a year ago

edited the original post as you pointed out the typo, thanks~

Joy Over a year ago

Thanks for your kind help. But my question is: normally the initializing is always false when the statement if ( !initializing && this.init ) is called, am I right? If always false, why use it?

Natural Lam Over a year ago

glad that helped. While it's great to learn fundamental JS, in case if you are not aware, ES6 has some native OO support (es6-features.org) Although it's not yet fully supported by all browsers, many people use transpilers like babel (babeljs.io) to transpile it to ES5 for now.

|

Collectives™ on Stack Overflow

John Resig's JavaScript inheritance implementation: why `initializing`?

Update

1 Answer 1

9 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

Update

1 Answer 1

9 Comments

Your Answer

Sign up or log in

Post as a guest

Related