Dans JavaScript, la classe peut être utilisée pour implémenter la programmation orientée objet. Cependant, les classes en JavaScript sont différentes de celles de Java, et leurs définitions et utilisations correspondantes sont également différentes.
Définition des classes en javascript
Dans JavaScript, tous les objets dérivés du même objet prototype (prototype) forment une classe; Autrement dit, les classes en JavaScript sont des concepts d'une collection d'objets. Si deux objets ont le même prototype, ils appartiennent à la même classe; Les classes de JavaScript n'ont même pas besoin de noms de classe. Le code suivant est un exemple:
La copie de code est la suivante:
var p = {x: 42};
var a = object.create (p);
var b = object.create (p);
console.log (a === b); // false
console.log (object.getprototypeof (a) === object.getprototypeof (b)); // true
Dans l'exemple ci-dessus, les objets A et B ont le même objet prototype (prototype) p, donc a et b appartiennent à la même classe (bien qu'aucune de cette classe n'ait un nom de classe), et ils héritent de la propriété x avec une valeur de 42 de l'objet prototype p.
À partir de cet exemple, nous pouvons voir que la fonction d'un objet prototype équivaut à un modèle, et plusieurs objets peuvent être dérivés / créés à partir de celui-ci. Son statut est le même que celui du code de classe dans la langue Java et est le cœur de la définition de classe dans JavaScript. L'objet prototype dans l'exemple suivant apparaîtra plus comme le code de classe:
La copie de code est la suivante:
var p = {
Incrément_by: 1,
Incrément: fonction (x) {
return x + this.increment_by;
}
}
var a = object.create (p);
var b = object.create (p);
console.log (a.increment (7)); // 8
console.log (b.increment (9)); // 10
Dans l'exemple ci-dessus, l'objet prototype P définit une propriété (incrément_by) avec une valeur de 1 et une fonction nommée incrément; Les objets A et B obtiennent les fonctions incrément_by et incrément à partir du modèle p. Lors de l'appel de la fonction d'incrément de l'objet A ou B, JavaScript essaiera d'obtenir la valeur incrément_by de A ou B (this.increment_by); Étant donné qu'aucment_by est obtenu à partir de p, ses valeurs sont toutes 1 - variables avec les mêmes valeurs, similaires aux variables de classe statique en Java. Par conséquent, dans l'exemple ci-dessus, tous les caractères de capital sont utilisés lors du nom de la variable incrémente_by.
Dans l'exemple ci-dessus, tous les objets créés à partir du modèle P (les objets appartenant à la même classe) ont les mêmes propriétés et comportements. Mais en fait, pour différents objets de la même classe, en plus d'avoir des attributs / comportements définis par la classe, ils ont souvent des attributs et des comportements uniques. Par conséquent, si vous avez besoin d'utiliser le modèle de prototype comme classe, vous devez personnaliser chaque objet en dérivé:
La copie de code est la suivante:
var p = {
Incrément_by: 1,
Incrément: fonction (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
var a = object.create (p);
var b = object.create (p);
A.Custom_increment_by = 0;
B.Custom_increment_by = 1;
console.log (a.increment (7)); // 8
console.log (b.increment (9)); // 11
Dans cet exemple, les objets A et B créés à partir du modèle P ont une variable Custom_inCrement_By dont les valeurs ne sont pas nécessairement égales les unes avec les autres, et le résultat final de leur comportement de fonction Incmentement () est lié à la valeur de Custom_increment_By. D'une manière générale, le travail de personnalisation de nouveaux objets est souvent effectué dans une fonction unifiée:
La copie de code est la suivante:
var p = {
Incrément_by: 1,
Incrément: fonction (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
function getIncrementalClassObject (CustomInCrementByValue) {
var incrémentalObj = object.create (p);
incrémentalObj.custom_increment_by = CustomInCrementByValue;
Retour incrémentalObj;
}
var a = getIncrementalClassObject (0);
var b = getIncrementalClassObject (1);
console.log (a.increment (7)); // 8
console.log (b.increment (9)); // 11
De cette façon, une définition de classe est terminée via les fonctions de l'objet Prototype P et GetInCrementalClassObject (): Les objets prototypes dont les objets prototypes sont P peuvent être obtenus en appelant la fonction GetInCrementalClassObject (), et ces nouveaux objets peuvent être personnalisés dans une certaine mesure au cours de la fonction GetIncrementalClassoBject (). Il convient de noter que cette classe définie n'a pas de nom de classe pour le moment. Par souci de description, il sera appelé incrémentiel.
En regardant en arrière le travail effectué dans la fonction GetInCrementalClassObject (), vous pouvez voir que le processus de création d'un nouvel objet à partir de la classe incrémentielle est le suivant:
1. Créez un objet vide et définissez son objet prototype comme p.
2. Personnalisez cet objet vide nouvellement créé en fonction des différentes valeurs de paramètres.
3. Renvoyez un nouvel objet personnalisé.
Dans JavaScript, vous pouvez rapidement terminer la définition de la classe et la création de nouveaux objets en utilisant le constructeur.
Constructeur (constructeur) en javascript
D'après l'exemple de la classe incrémentielle ci-dessus, nous pouvons voir que la définition d'une nouvelle classe nécessite deux parties de code: la création d'un objet prototype comme modèle, créant une fonction personnalisée pour initialiser le nouvel objet; La création d'un nouvel objet à partir d'une classe passe par trois processus: spécifiant l'objet Prototype du nouvel objet, personnalisant / initialisation du nouvel objet et renvoyant ce nouvel objet. Dans JavaScript, tout cela peut être fait via le constructeur (constructeur).
Le constructeur de JavaScript est une fonction qui assume la responsabilité d'initialiser un nouvel objet; Le prototype de cette fonction de constructeur est utilisé comme modèle pour créer un nouvel objet. Prenant l'exemple de la classe incrémentielle ci-dessus, après avoir utilisé le constructeur pour réécrire le code, cela ressemble à ceci:
La copie de code est la suivante:
fonction incrémentielle (personnalisation decrementByValue) {
this.custom_increment_by = CustomInCrementByValue;
}
Incrémentiel.prototype = {
Incrément_by: 1,
Incrément: fonction (x) {
return x + this.increment_by + this.custom_increment_by;
}
}
var a = nouveau incrémentiel (0);
var b = nouveau incrémentiel (1);
console.log (a.increment (7)); // 8
console.log (b.increment (9)); // 11
Le processus de création d'un nouvel objet utilisant la fonction du constructeur via le nouveau mot clé passe en fait par les étapes suivantes:
Créez un nouvel objet vide.
1. Poignez l'objet Prototype de cet objet à la propriété Prototype de la fonction du constructeur.
2. Utilisez cet objet comme ce paramètre et exécutez la fonction du constructeur.
3. C'est la même chose que les travaux précédents effectués dans la fonction GetInCrementalClassObject ().
Nom de classe
Lors de la création d'un objet à l'aide du constructeur, l'objet correspondant a un "nom de classe", qui peut être vérifié à partir du résultat de l'instance de l'opérateur:
La copie de code est la suivante:
console.log (une instance de progressivité); // vrai
console.log (b instance of incrémentiel); // true
Cependant, l'opérateur d'instance ne détermine pas si l'objet est créé par le constructeur incrémentiel. L'opérateur InstanceOf détermine uniquement si l'objet prototype de l'objet est incrémentiel. ProTotype. Lorsqu'il y a deux constructeurs avec le même prototype, l'opérateur d'instance de retournera uniformément sans distinguer quel constructeur est utilisé pour créer l'objet.
La copie de code est la suivante:
fonction incrémentielle2 (personnalisation decrementByValue) {
this.custom_increment_by = CustomInCrementByValue + 3;
}
Incrémentiel2.prototype = Prototype incrémentiel;
console.log (une instance de incrémentiel2); // true