Les constructeurs de JavaScript sont également différents des autres langues. Toute fonction appelée via le mot-clé nouveau peut être considérée comme un constructeur.
À l'intérieur du corps du constructeur, cela pointe vers l'objet nouvellement créé. S'il n'y a pas d'expression de retour affichée dans le corps du constructeur, nous retournerons cela par défaut, c'est-à-dire l'objet nouvellement créé.
La copie de code est la suivante:
fonction foo () {
this.bla = 1;
}
Foo.prototype.test = function () {
console.log (this.bla);
};
Var test = new foo ();
Le code ci-dessus appelle Foo comme constructeur et pointe le prototype de l'objet nouvellement créé (__proto__) à foo.prototype.
Si nous définissons l'expression retournée dans le constructeur, le constructeur renvoie toute l'expression, mais cette expression de retour doit être un objet.
La copie de code est la suivante:
Function Bar () {
retour 2;
}
Nouveau bar (); // un nouvel objet
fonction test () {
this.value = 2;
retour {
foo: 1
};
}
nouveau test (); // l'objet retourné
Si nouveau est omis, la fonction ne peut pas renvoyer un nouvel objet.
La copie de code est la suivante:
fonction foo () {
this.bla = 1; // est réglé sur l'objet global
}
Foo (); // indéfini
L'exemple ci-dessus peut également fonctionner dans certains scénarios, mais en raison du mécanisme de travail de cela en JavaScript, cela indiquera l'objet global ici.
Modèle d'usine
Afin de pouvoir utiliser le mot-clé nouveau, le constructeur devra afficher une valeur de retour.
La copie de code est la suivante:
Function Bar () {
Var Vale = 1;
retour {
Méthode: fonction () {
valeur de retour;
}
}
}
Bar.prototype = {
foo: function () {}
};
Nouveau bar ();
Bar();
Dans l'exemple ci-dessus, l'effet d'appeler la barre de fonction sans utiliser de nouveau est le même, et un objet nouvellement créé contenant la méthode sera retourné, ce qui est en fait une fermeture.
Une chose à noter ici est que New Bar () ne renverra pas BAR.prototype, mais sera plutôt un objet prototype de la méthode de fonction à l'intérieur de l'expression de retour.
Dans l'exemple ci-dessus, il n'y a pas de différence de fonctionnalité entre l'utilisation du nouveau ou non.
Créer de nouveaux objets via le mode d'usine
Nous nous rappelons souvent de ne pas utiliser de nouvelles car une fois que vous oubliez son utilisation, cela entraînera des erreurs.
Pour créer un objet, nous préférons utiliser le modèle d'usine et construire un nouvel objet dans le modèle d'usine.
La copie de code est la suivante:
fonction foo () {
var obj = {};
obj.value = 'blub';
var privé = 2;
obj.somemethod = function (valeur) {
this.value = valeur;
}
obj.getprivate = function () {
retourner privé;
}
retour obj;
}
Bien que l'exemple de code ci-dessus soit moins sujet aux erreurs que lors de l'utilisation de nouveaux et sera plus pratique lors de l'utilisation de variables privées, il existe certains inconvénients:
Étant donné que les objets prototypes ne peuvent pas être partagés, plus de mémoire est requise.
Pour atteindre l'héritage, le modèle d'usine nécessite de copier toutes les méthodes d'un autre objet ou de l'utiliser comme prototype d'un nouvel objet.
L'abandon de la chaîne prototype est juste d'éviter d'utiliser de nouvelles, ce qui semble être contraire à l'esprit de la langue javascript.
Résumer
Bien que l'utilisation de nouveaux puisse être plus sujets aux erreurs, ce n'est pas une raison d'abandonner l'utilisation de chaînes prototypes. Quant à la méthode à prendre à la fin, cela dépend des besoins de l'application. La meilleure façon est de choisir un style et de s'y tenir.
Autrement dit, le constructeur consiste à initialiser un objet d'instance, et la propriété prototype de l'objet hérite d'un objet d'instance.