propriétés des prototypes et des objets constructeurs

constructor est un régulier de propriété de l'objet prototype (avec le DontEnum indicateur est défini de sorte qu'il n'apparaît pas dans for..in boucles). Si vous remplacez le prototype de l'objet, de la constructor propriété sera remplacé comme bien voir cette explication pour plus de détails.

Vous pouvez contourner le problème en réglant manuellement Obj2.prototype.constructor = Obj2mais de cette façon, le DontEnum drapeau ne sera pas réglé.

En raison de ces problèmes, ce n'est pas une bonne idée de compter sur constructor pour la vérification du type: utilisation instanceof ou isPrototypeOf() à la place.

Andrey Fedorov a soulevé la question de savoir pourquoi new ne pas affecter la constructor propriété de l'instance de l'objet à la place. Je suppose que la raison pour cela est le long des lignes suivantes:

Tous les objets créés à partir de la même fonction constructeur partager le constructeur de la propriété, et les propriétés partagées résider dans le prototype.

Le vrai problème, c'est que JavaScript n'a pas de prise en charge intégrée des hiérarchies d'héritage. Il existe plusieurs façons de contourner le problème (le vôtre est l'un de ceux-ci), un autre plus "dans l'esprit" de JavaScript serait le suivant:

function addOwnProperties(obj /*, ...*/) {
    for(var i = 1; i < arguments.length; ++i) {
        var current = arguments[i];

        for(var prop in current) {
            if(current.hasOwnProperty(prop))
                obj[prop] = current[prop];
        }
    }
}

function Obj1(arg1) {
    this.prop1 = arg1 || 1;
}

Obj1.prototype.method1 = function() {};

function Obj2(arg1, arg2) {
    Obj1.call(this, arg1);
    this.test2 = arg2 || 2;
}

addOwnProperties(Obj2.prototype, Obj1.prototype);

Obj2.prototype.method2 = function() {};

Cela rend le multi-héritage trivial.

Version courte: ‘constructeur’ ne fait pas ce que vous en pensez, et n'est pas compatible avec tous les navigateurs. Ne jamais l'utiliser.

Version longue: Convention pour le prototype de l'héritage en JavaScript

Généralement: vous êtes confus en raison (a) de l'impédance d'incompatibilité entre une classe et d'un prototype de base OO, et (b) l'étrangeté du JavaScript particulier plutôt mauvaise interprétation de prototype à base de OO.

Vous aurez probablement à être plus heureux si vous trouvez l'une des classes-dans-les prototypes de mise en œuvre que vous aimez et s'en tenir à cela. Beaucoup de bibliothèques ont un. Voici un arbitraire celui que j'utilise:

Function.prototype.subclass= function() {
    var c= new Function(
        'if (!(this instanceof arguments.callee)) throw(\'Constructor called without "new"\'); '+
        'if (arguments[0]!==Function.prototype.subclass.FLAG && this._init) this._init.apply(this, arguments); '
    );
    if (this!==Object)
        c.prototype= new this(Function.prototype.subclass.FLAG);
    return c;
}
Function.prototype.subclass.FLAG= new Object();

Et voici un exemple de comment on pourrait l'utiliser:

//make a new class
var Employee= Object.subclass();

//add members to it
Employee.prototype._LEGS= 2;
Employee.prototype.getLegs= function() {
    return this._LEGS;
};

//optional initialiser, takes arguments from constructor
Employee.prototype._init= function(name) {
    this.name= name;
};

//make a subclass
Manager= Employee.subclass();

//extend subclass method
Manager.prototype._init= function(name, importance) {
    //call base class's method
    Employee.prototype._init.call(this, name);
    this.importance= importance;
}

//all managers are well-known to have three legs
Manager.prototype._LEGS= 3;

//create one
var jake= new Manager('Jake the Peg', 100);