Propriétés de l'objet prototype et constructeur

J'ai:

function Obj1(param) { this.test1 = param || 1; } function Obj2(param, par) { this.test2 = param; } 

Maintenant quand je fais:

 Obj2.prototype = new Obj1(44); var obj = new Obj2(55); alert(obj.constructor) 

J'ai:

 function Obj1(param) { this.test1 = param || 1; } 

Mais la fonction constructeur a été Obj2 … pourquoi ça? Obj1 est devenu le prototype Obj2 …

Quelqu'un peut-il m'expliquer en détail la chaîne prototype et la propriété constructeur?

Merci

  • Firefox ne changera pas la source d'image
  • Comment puis-je obtenir "this = this" en mode prototype
  • ES6 - déclarer une méthode de prototype sur une classe avec une déclaration d'importation
  • Que fait le nouveau mot-clé sous le capot?
  • Définir Object.prototype .__ proto__ au lieu de simplement Object.prototype?
  • Empêcher ASP.NET MVC de remplacer la période par un trait de soulignement dans Html Helper IDs
  • Prototype Javascript vs Fonctions générales - Performance / lisibilité
  • Comprendre mieux l'architecture Javascript OOP
  • 4 Solutions collect form web for “Propriétés de l'objet prototype et constructeur”

    constructor est une propriété régulière de l'objet prototype (avec l' DontEnum drapeau DontEnum pour qu'il ne s'affiche pas dans les boucles for..in ). Si vous remplacez l'objet prototype, la propriété constructor sera également remplacée – voir cette explication pour plus de détails.

    Vous pouvez contourner le problème en configurant manuellement Obj2.prototype.constructor = Obj2 , mais de cette façon, le drapeau DontEnum ne sera pas défini.

    En raison de ces problèmes, il n'est pas judicieux de s'appuyer sur le constructor pour la vérification de type: utilisez instanceof ou isPrototypeOf() place.


    Andrey Fedorov a soulevé la question de savoir pourquoi new n'attribue pas la propriété constructor à l'objet d'instance. Je suppose que la raison en est la suivante:

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

    Le vrai problème est que JavaScript n'a pas de support intégré pour les hiérarchies d'héritage. Il existe plusieurs façons de résoudre le problème (le vôtre est l'un de ceux-ci), un autre «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 l'héritage multiple également trivial.

    Découvrez le OOP de Tom Trenka , ECMAscript , la page "Héritage". Tout ce qui provient du prototype est hérité, y compris la propriété constructor . Ainsi, nous devons nous débrouiller nous-mêmes:

     Obj2.prototype = new Obj1(42); Obj2.prototype.constructor = Obj2; 

    Version courte: 'constructeur' ne fait pas ce que vous pensez et n'est pas compatible avec le navigateur. Ne l'utilisez jamais.

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

    Généralement: vous êtes confondu en raison de (a) l'incompatibilité d'impédance entre OO basé sur les classes et les prototypes, et (b) l'étrangeté de l'interprétation particulière plutôt mauvaise de JavaScript de l'OO prototype.

    Vous serez probablement plus heureux si vous trouvez une implémentation de classes en prototypes que vous aimez et que vous y adhérez. Beaucoup de bibliothèques ont une. Voici un arbitraire 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); 

    Bien, la propriété constructeur est une propriété comme toute autre, sur le prototype (propriété) d'Obj1. Si vous comprenez comment les prototypes fonctionnent , cela pourrait aider:

     >>> obj.hasOwnProperty("constructor") false // obj's [[Prototype]] is Obj2.prototype >>> Obj2.prototype.hasOwnProperty("constructor") false // Obj2.prototype's [[Prototype]] is Obj1.prototype >>> Obj1.prototype.hasOwnProperty("constructor") true // Oh? >>> Obj1.prototype.constructor Obj1() 

    Aha! Donc obj n'a pas de constructeur, JS va chercher la chaîne [[Prototype]], tout le chemin depuis Obj1.prototype.constructor

    Je ne sais pas pourquoi la propriété constructeur n'est pas seulement définie sur un objet lorsque vous utilisez `new '. Il pourrait y avoir une raison, ou cela pourrait être un oubli. Quoi qu'il en soit, j'ai tendance à l'éviter.

    JavaScript rend le site Web intelligent, beauté et facile à utiliser.