Ce qu’elle l’importance de la propriété du constructeur Javascript ?

Question

Tenter de plier en tête autour de Javascript sur OO...et, comme beaucoup d'autres, en cours d'exécution dans la confusion à propos de l' constructor de la propriété. En particulier, l'importance de l' constructor de la propriété, que je n'arrive pas à faire un quelconque effet. E. g.:

function Foo(age) {
    this.age = age;
}

function Bar() {
    this.name = "baz"; 
}

Bar.prototype = new Foo(42); 
var b = new Bar;    

alert(b.constructor); // "Foo". That's OK because we inherit `Foo`'s prototype.
alert(b.name);        // "baz". Shows that Bar() was called as constructor.
alert(b.age);         // "42", inherited from `Foo`.

Dans l'exemple ci-dessus, l'objet b semble avoir eu le droit constructeur appelé (Bar) – et il hérite de la propriété age de Foo. Alors pourquoi beaucoup de gens suggèrent cela comme une étape nécessaire:

Bar.prototype.constructor = Bar;

Clairement, le droit Bar constructeur a été appelée lors de la construction d' b, donc quel est l'impact de cette propriété prototype? Je suis curieux de savoir quelle différence cela fait vraiment avoir la propriété constructor set 'correctement'-que je ne le vois pas avoir une incidence sur quel constructeur est en fait appelé après qu'un objet est créé.

Answer 1

La première étape est de comprendre ce qu' constructor et prototype . Il n'est pas difficile, mais on doit se laisser aller, de "l'héritage" dans le sens classique du terme.

Le constructeur

L' constructor de la propriété ne cause aucun effet particulier dans votre programme, sauf que vous pouvez regarder pour voir lequel la fonction a été utilisé en conjonction avec l'opérateur new créer votre objet. Si vous avez tapé new Bar() il sera Bar et que vous avez tapé new Fooil sera Foo.

Le prototype

L' prototype propriété est utilisé pour la recherche dans le cas où l'objet en question ne possède pas la propriété demandé. Si vous écrivez x.attr, JavaScript, essayez de trouver attr entre xs'attributs. Si il ne peux pas le trouver, il va chercher en x.__proto__. Si elle n'est pas là non plus, il va regarder dans x.__proto__.__proto__ et ainsi de suite tant que __proto__ est défini.

Donc, qu'est - __proto__et qu'est ce que ca a à voir avec l' prototype? Peu de temps mis, prototype c'est pour les "types" tout en __proto__ c'est pour les "instances". (Je dis ça avec des guillemets car il n'y a pas vraiment de différence entre les types et instances). Lorsque vous écrivez x = new MyType(), ce qui se passe (entre autres choses), c'est qu' x.__proto___ est définie à l' MyType.prototype.

La question

Maintenant, le dessus doit être tout ce que vous devez tirer de ce que votre propre exemple, que les moyens, mais pour essayer de répondre à votre question; "pourquoi écrire quelque chose comme":

Bar.prototype.constructor = Bar;

Personnellement, je ne l'ai jamais vu et je trouve ça un peu ridicule, mais dans le contexte que vous avez donné, il signifie que l' Bar.prototype-objet (créé à l'aide de new Foo(42)) posera comme l'ont créé en Bar plutôt que d' Foo. Je suppose que l'idée est quelque faire quelque chose de similaire à C++/Java/C#-comme les langues où un type de recherche ( constructor de la propriété) produisent toujours les plus spécifiques de type plutôt que le type de la plus générique de l'objet dans le prototype de la chaîne.

Mon conseil: ne pense pas que beaucoup au sujet de "l'héritage" en JavaScript. Les concepts d'interfaces et de mixin a plus de sens. Et de ne pas vérifier les objets de leurs types. Vérifier les propriétés requises à la place ("si ça marche comme un canard et des charlatans comme un canard, c'est un canard").

En essayant de forcer JavaScript dans un classique modèle d'héritage, quand tout ce qu'il a est le prototype du mécanisme, comme décrit ci-dessus, c'est ce qui provoque la confusion. Les nombreuses personnes qui ont suggéré de définir manuellement l' constructor-propriété probablement essayé de faire exactement cela. Les Abstractions sont bien, mais de ce manuel à la cession de la propriété constructeur n'est pas très idiomatique de l'utilisation de JavaScript.

Answer 2

La propriété constructor fait absolument aucune différence pratique en interne. C'est seulement une utilisation si votre code l'utilise explicitement. Par exemple, vous pouvez décider que chacun de vos objets doit avoir une référence à la fonction constructeur réelle qui l'a créé. Si c'est le cas, vous devez définir explicitement la propriété constructor lorsque vous configurez l'héritage en affectant un objet à la propriété prototype d'une fonction constructeur, comme dans votre exemple.

Answer 3

un cas d'utilisation du constructeur:

1. c'est l'une des réalisations courantes de l'héritage:

    Function.prototype.extend = function(superClass,override) {
       var f = new Function();
       f.prototype = superClass.prototype;
       var p = this.prototype = new f();
       p.constructor = this;
       this.superclass = superClass.prototype;
       ...
   };
    

2. this new f() n'appellerait pas le constructeur de superClass, donc lorsque vous créez une sous-classe, vous devez peut-être d'abord appeler la super-classe, comme ceci:

    SubClass = function() {
       SubClass.superClass.constructor.call(this);
   };
    

donc la propriété constructeur a du sens ici.