1. Qu'est-ce qu'un constructeur
Les constructeurs sont très communs dans certaines langues orientées objet telles que Java, C ++ et PHP. Dans JavaScript, le constructeur est d'abord une fonction normale, qui peut être appelée en utilisant le nouvel opérateur et génère un objet de type spécial.
La copie de code est la suivante:
// "Benjamin" est un constructeur
var benjamin = new benjamin ("zuojj", "mâle");
Dans l'exemple ci-dessus, Benjamin est un objet Benjamin, alors comment est-il instancié?
La copie de code est la suivante:
fonction benjamin (nom d'utilisateur, sexe) {
this.userName = nom d'utilisateur;
this.sex = sexe;
}
var benjamin = new benjamin ("zuojj", "mâle");
// Sorties: Benjamin {sexe: "mâle", nom d'utilisateur: "Zuojj"}
Console.log (Benjamin);
Comme nous pouvons le voir, le constructeur "Benjamin" reçoit simplement des paramètres passés et les attribue à cet objet. En effet, lorsque le constructeur est appelé par le nouvel opérateur, cet objet du constructeur est attribué à l'objet renvoyé par la nouvelle opération.
Cela signifie que le code ci-dessus est équivalent à:
La copie de code est la suivante:
benjamin = {
"nom d'utilisateur": "Zuojj",
"Sex": "Homme"
}
2. Pourquoi utiliser les constructeurs
Il y a plusieurs raisons pour lesquelles les constructeurs sont utilisés:
1. Utiliser des constructeurs signifie que tous ces objets peuvent être créés en utilisant la même structure de base.
2. L'utilisation d'un constructeur signifie que l'objet "Benjamin" est explicitement marqué comme une instance de la fonction "Benjamin"
La copie de code est la suivante:
fonction benjamin (nom d'utilisateur, sexe) {
this.userName = nom d'utilisateur;
this.sex = sexe;
}
var benjamin = new benjamin ("zuojj", "mâle");
var ben = {
"nom d'utilisateur": "Zuojj",
"Sex": "Homme"
}
// sorties: vrai
Console.log (Benjamin Instructionof Benjamin);
// Sorties: Faux
Console.log (Ben Instructionof Benjamin);
3. Utiliser des constructeurs signifie que nous pouvons définir des méthodes publiques sur le prototype pour partager plusieurs instances
La copie de code est la suivante:
fonction benjamin (nom d'utilisateur, sexe) {
this.userName = nom d'utilisateur;
this.sex = sexe;
}
Benjamin.prototype.getName = function () {
Renvoyez ceci.Username;
}
var benjamin = new benjamin ("zuojj", "mâle");
var ben = new Benjamin ("citron", "femelle");
// Sorties: Zuojj
console.log (benjamin.getName ());
// Sorties: citron
console.log (ben.getName ());
3. Choses à noter
1.Neuf mots clés
Lors de l'instanciation du constructeur, vous ne devez pas oublier d'utiliser le nouveau mot-clé. Le fait d'utiliser le nouveau mot-clé aura un grand impact sur cet objet. Sans le nouveau mot clé, cet objet pointera vers l'objet global (fenêtre dans le navigateur et global dans le nœud). Par conséquent, lors de la définition d'un constructeur, il est recommandé que la première lettre du nom de la fonction soit capitalisée.
2. Si la fonction appelée n'a pas d'expression de retour explicite, cet objet sera renvoyé implicitement, qui est l'objet nouvellement créé. Sinon, le résultat sera affecté, mais seulement si l'objet retourné est
La copie de code est la suivante:
Function Bar () {
retour 2;
}
var bar = new bar ();
// Renvoie l'objet nouvellement créé
// Sorties: bar {}
console.log (bar);
fonction test () {
this.value = 2;
retour {
foo: 1
};
}
var test = nouveau test ();
// objet retourné
// Sorties: objet {foo: 1}
console.log (test);
Ce à quoi nous devons faire attention, c'est:
a) new BAR () renvoie l'objet nouvellement créé, pas la valeur littérale du nombre 2. Par conséquent, new BAR (). Constructor === Bar, mais si l'objet numéro renvoyé, le résultat sera différent;
b) Le nouveau test () obtenu ici est un objet renvoyé par la fonction, pas un objet nouvellement créé via le nouveau mot-clé, comme indiqué ci-dessous:
La copie de code est la suivante:
Function Bar () {
retour 2;
}
var bar = new bar ();
fonction Barn () {
renvoyer le nouveau numéro (2);
}
var Barn = new Barn ();
// sorties: vrai
console.log (bar.constructor === bar);
// Sorties: numéro {}
console.log (grange);
// ouputs: faux
Console.log (Barn.Constructor === Barn);
// sorties: vrai
Console.log (Barn.Constructor === Number);
/ * -------------------------------------- * /
fonction test () {
this.value = 2;
retour {
foo: 1
};
}
var test = nouveau test ();
// Sorties: indéfinie
console.log (test.Value);
// ouputs: 1
console.log (test.foo);
Ce qui précède est un résumé du constructeur. J'espère que ce sera utile aux débutants. S'il y a des points inappropriés dans l'article, j'espère les critiquer et les corriger.