Tout dans JavaScript est un objet: chaîne, tableau, valeur, fonction, etc. Il n'y a pas de concept dans JS,
Mais nous pouvons utiliser les caractéristiques grammaticales de JS pour créer des objets avec l'idée de classe.
Méthode originale
Copier le code du code comme suit:
<script type = "text / javascript">
var obj = nouveau objet ();
obj.name = "koji";
obj.age = 21;
obj.showname = function () {// Ajouter une méthode à l'objet
Alert (this.name);
}
obj.showage = function () {
alerte (this.age);
}
obj.showname ();
obj.showage ();
</cript>
La méthode ci-dessus génère un objet via le nouveau mot clé, puis ajoute les propriétés et les méthodes des caractéristiques du langage dynamique selon le JS.
Créer un objet. Parmi eux, il s'agit d'un objet qui appelle la méthode.
Le problème de cette manière est que si vous devez créer un objet plusieurs fois, le code doit être répété plusieurs fois, ce qui n'est pas propice à la réutilisation du code.
Méthode d'usine
Copier le code du code comme suit:
<script type = "text / javascript">
fonction createoBj () {
var obj = nouveau objet ();
obj.name = "koji";
obj.age = 21;
obj.showname = function () {
Alert (this.name);
}
obj.showage = function () {
alerte (this.age);
}
Retour obj; // retour à l'objet
}
var obj1 = createObj ();
var obj2 = createObj ();
obj1.showname ();
obj2.showage ();
</cript>
Cette méthode améliore le taux de réutilisation du code et peut également modifier la méthode d'usine et passer l'affectation des paramètres.
Copier le code du code comme suit:
<script type = "text / javascript">
Fonction createoBj (nom, âge) {// Lors de la construction d'objets, le paramètre d'initialisation peut être passé
var obj = nouveau objet ();
obj.name = name;
obj.age = âge;
obj.showname = function () {
Alert (this.name);
}
obj.showage = function () {
alerte (this.age);
}
Retour obj; // retour à l'objet
}
var obj1 = createObj ("koji", 22);
var obj2 = createObj ("Luo", 21);
obj1.showname ();
obj1.showage ();
obj2.showname ();
obj2.showage ();
</cript>
Bien que la méthode ci-dessus puisse augmenter le taux de renouvellement du code, il a un grand défaut par rapport au concept de la classe orientée objet. nouille
L'image relative met l'accent sur la propriété de l'objet et la méthode de l'objet est partagée. Et la méthode d'usine ci-dessus pour créer l'objet l'un pour l'autre
Les objets créent leurs propres méthodes égoïstes. En même temps, la même méthode de création de la même logique pour chaque objet est un gaspillage de mémoire. Amélioré comme suit
Copier le code du code comme suit:
<span style = "font-size: 14px;"> <script type = "text / javascript">
Fonction createObj (name, age) {{{
var obj = nouveau objet ();
obj.name = name;
obj.age = âge;
obj.showname = wamedame;
obj.showage = renforcement;
Retour obj; // retour à l'objet
}
Fonction wamedame () {// La fonction est également un objet
Alert (this.name);
}
fonction show () {
alerte (this.age);
}
var obj1 = createObj ("koji", 22);
var obj2 = createObj ("Luo", 21);
obj1.showname ();
obj1.showage ();
obj2.showname ();
obj2.showage ();
</cript> </span>
Les objets de fonction mentionnés ci-dessus sont définis pour résoudre les problèmes privés de différents objets de fonction d'objet d'objets. Maintenant tous les objets sont
Maintenez la référence aux deux fonctions ci-dessus. Mais de cette manière, la fonction de l'objet est devenue indépendante et hors de propos pour l'objet. Ceci et
Des méthodes spécifiques pour les méthodes spécifiques orientées objet ne répondent pas aux pensées de catégories spécifiques.
Méthode des fonctions de construction
Copier le code du code comme suit:
<script type = "text / javascript">
// Définissez un constructeur pour générer l'objet correspondant.
Personne de fonction (nom, âge) {
// Lorsque vous appelez une nouvelle personne, avant d'exécuter la première ligne de code, une personne est un objet de personne et l'objet est dans la mémoire
// L'attribution d'index est donnée à ce mot-clé.
This.name = name; // ces mots clés ne doivent pas être moins. Pour l'objet actuel, c'est-à-dire l'affectation d'attribut de nom de l'objet référencé par ce mot-clé
//, il équivaut en fait à l'ajout de la propriété de nom à l'objet actuel, puis attribue une valeur à son attribut de nom.
this.age = âge;
this.showname = function () {// ajouter la méthode à l'objet actuel
Alert (this.name);
}
this.showage = function () {
alerte (this.age);
}
// Renvoie l'objet actuel à la variable à gauche du symbole d'attribution (pas besoin d'utiliser le retour)
}
Var obj1 = new personne ("koji", 22);
var obj2 = new personne ("Luo", 21);
obj1.showname ();
obj1.showage ();
obj2.showname ();
obj2.showage ();
</cript>
La méthode de construction d'une fonction est la même que la méthode d'usine, et il créera un objet de fonction exclusif pour chaque objet. Bien sûr, vous pouvez également mettre ces fonctions
L'objet est défini à l'extérieur du constructeur, de sorte que les objets et les méthodes sont indépendants les uns des autres.
Méthode prototype: la propriété prototype de l'objet utilisé par cette méthode
Copier le code du code comme suit:
script type = "text / javascript">
Function Person () {} // Définir une fonction à air-confli, et ne peut pas passer les paramètres
// donne toutes les méthodes de tous les attributs à l'attribut prototype
Personne.prototype.name = "koji";
Personne.prototype.age = 22;
Personne.prototype.showname = function () {// ajouter la méthode
Alert (this.name);
}
Personne.prototype.showage = function () {
alerte (this.age);
}
var obj1 = new personne ();
var obj2 = new personne ();
obj1.showname ();
obj1.showage ();
obj2.showname ();
obj2.showage ();
</cript>
Lorsque l'objet personne est généré, les attributs du prototype sont attribués au nouvel objet. Ensuite, les attributs et les méthodes sont partagés.
Le problème de cette méthode est que le constructeur ne peut pas être transmis et que chaque objet nouvellement généré a la valeur par défaut. Deuxièmement, le partage de méthode ne sera pas partagé
Tout problème, mais le partage d'attribut est un problème, lorsque l'attribut est l'objet qui peut modifier l'état.
Copier le code du code comme suit:
<script type = "text / javascript">
Function Person () {} // Définir une fonction à air-confli, et ne peut pas passer les paramètres
Personne.prototype.age = 22;
Personne.prototype.array = new Array ("koji", "luo");
Personne.prototype.showage = function () {
alerte (this.age);
}
Personne.prototype.showArray = function () {
Alerte (this.array);
}
var obj1 = new personne ();
var obj2 = new personne ();
obj1.array.push ("kyo");
obj1.showArray ();
obj2.showArray ();
</cript>
Lorsque le code ci-dessus ajoute des éléments à l'attribut d'OBJ1 à l'attribut d'OBJ1, l'élément de l'attribut Arra d'OBJ2 suit également
L'impact est que la propriété du tableau d'objets Obj1 et Obj2 cite le même objet de tableau, alors modifiez ce tableau
Objet, l'attribut de l'objet Array sera naturellement affecté naturellement
Méthode de constructeur / prototype mixte
Utilisez le constructeur pour définir les attributs de l'objet et utiliser le prototype pour définir des objets, afin que l'attribut puisse être réalisé
Partage privé et méthode.
Copier le code du code comme suit:
<script type = "text / javascript">
Personne de fonction (nom, âge) {
this.name = name;
this.age = âge;
this.array = new Array ("koji", "luo");
}
Personne.prototype.showname = function () {
Alert (this.name);
}
Personne.prototype.showArray = function () {
Alerte (this.array);
}
Var obj1 = new personne ("koji", 22);
var obj2 = new personne ("Luo", 21);
obj1.array.push ("kyo");
obj1.showArray ();
obj1.showname ();
obj2.showArray ();
obj2.showname ();
</cript>
Une fois que les attributs sont privés, la modification de leurs attributs respectifs n'affectera pas d'autres objets. En même temps, la méthode est également partagée par chaque objet. Sémantiquement,
Cela répond aux exigences de la programmation FACE-Object.
Prototype dynamique
Copier le code du code comme suit:
<script type = "text / javascript">
Personne de fonction (nom, âge) {
this.name = name;
this.age = âge;
this.array = new Array ("koji", "luo");
// Si l'objet _Initialized dans l'objet de personne n'est pas défini, il indique qu'il n'a pas encore ajouté de méthode au prototype de personne
ifof personne._Initialized == "Underfined")
{{
Personne.prototype.showname = function () {
Alert (this.name);
}
Personne.prototype.showArray = function () {
Alerte (this.array);
}
Personne._Initialized = true;
}
}
Var obj1 = new personne ("koji", 22);
var obj2 = new personne ("Luo", 21);
obj1.array.push ("kyo");
obj1.showArray ();
obj1.showname ();
obj2.showArray ();
obj2.showname ();
</cript>
Cette méthode est similaire au constructeur / prototype. Mettez simplement la méthode dans le constructeur, tout en même temps
Un attribut est ajouté à la personne de la fonction pour s'assurer que l'instruction IF ne peut être exécutée avec succès qu'une seule fois
Le plus largement utilisé dans les applications pratiques est la méthode du constructeur / prototype. La méthode du prototype dynamique est également très populaire, elle a des fonctions et une structure
La méthode de fonction / prototype est équivalente. N'utilisez pas le constructeur ou la méthode prototype seul.