1. Utilisation des classes de base
Méthode 1:
La copie de code est la suivante:
fonction sth (a) // fonction constructeur
{
this.a = a;
this.fun = output; // fonction membre
}
Sortie de fonction (a, b, c)
{
Document.Write (this.a);
}
//Appel
var s = new SH (250);
S.Fun (1, 2, 3);
ouput (1, 2, 3); // Si la sortie est erronée avant STH
Méthode 2:
Copiez le code comme suit: fonction sth (a)
{
this.a = a;
this.output = function ()
{
Document.Write (this.a);
}
}
var s = new SH (2);
S.Output (); // Sortie 2
2. Héritage
Méthode 1:
Copiez le code comme suit: Fonction A (x)
{
this.x = x;
}
Fonction B (x, y)
{
// Méthode 1
/ *
this.construct = a;
this.construct (x);
Supprimer ceci.Construct;
* /
// Méthode 2
//A.Call (This, x);
// Méthode 3
A.Apply (ceci, nouveau tableau (x)); // il peut également être a.apply (ceci, arguments), mais l'ordre des paramètres d'argument doit être correct
this.y = y;
this.print = function ()
{
document.write ("x =", x,
", y =", y);
}
}
var b = new B (1, 2);
b.print ();
alerte (b instance a); // Sortie fausse
Avantages: l'héritage multiple peut être réalisé (il suffit d'appeler plusieurs appels)
défaut:
・ Doit être utilisé comme constructeur
・ Utilisez l'opérateur d'instance pour exploiter ce résultat de l'héritage à false
Méthode 2:
Copiez le code comme suit: Fonction A ()
{
}
A.prototype.x = 1;
fonction b ()
{
}
B.Prototype = new A (); // ne peut pas prendre de paramètres!
B.prototype.y = 2;
B.prototype.print = fonction ()
{
document.write (this.x, ",", this.y, "<br>");
}
var b = new b ();
b.print ();
Document.Write (B Instance Of A); // Sortie True
défaut:
・ Je ne peux pas atteindre l'héritage multiple
・ Le constructeur n'a pas de paramètres
Conseils
Généralement en utilisant un mode hybride, les deux
La copie de code est la suivante:
fonction a (x)
{
this.x = x;
}
A.prototype.printx = fonction () // écrivez this.printx = fonction .... il est également possible, le même ci-dessous
{
document.write (this.x, "<br>");
}
Fonction B (x, y)
{
A.Call (ceci, x);
this.y = y;
}
B.Prototype = new A (); // ne peut pas prendre de paramètres!
B.prototype.printxy = fonction ()
{
document.write (this.x, ",", this.y, "<br>");
}
var b = new B (1, 2);
b.printx (); // Sortie 1
b.printxy (); // Sortie 1, 2
Document.Write (B Instance Of A); // Sortie True
3. Utilisation des fonctions des membres statiques
Copiez le code comme suit: fonction sth (a)
{
this.a = a;
}
STH.FUN = fonction (s)
{
Document.Write (SA);
}
var s = new SH (2);
SH.FUN (S); // Sortie 2
Iv. Libération d'objets
Copiez le code comme suit: var obj = nouvel objet; // obj est une référence
obj = null; // Dereference sera automatiquement des ordures de la collecte; Si vous devez libérer cet objet, toutes ses références doivent être affectées à Null
V. objet de fonction
Copiez le code comme suit: var v = nouvelle fonction ("arg1", "arg2", "document.write (arg1 + arg2);"); // définir un objet de fonction avec les paramètres Arg1 et Arg2 respectivement
V (1, 2); // sortira 3
6. Fonction de rappel
Copiez le code comme suit: Rappel des fonctions (Func, Arg)
{
func (arg);
}
fonction amusante (arg)
{
Document.Write (Arg);
}
// rappel (func, "sb"); // Cette méthode ne fonctionne pas
var func = nouvelle fonction ("arg", "fun (arg);");
// Bien sûr, Func (Arg) peut également être remplacé par un code d'exécution spécifique.
// mais si le code de fonction est énorme, il vaut mieux le faire
rappel (func, "sb");
7. Surcharge de fonction
Copiez le code comme suit: Function Fun ()
{
commutateur (arguments.length)
{
Cas 1:
document.write (arguments [0]);
casser;
Cas 2:
Document.Write (arguments [0] + Arguments [1]);
casser;
défaut:
document.write ("Error!");
casser;
}
}
plaisir (1);
plaisir (1, 2);
8. Utilisez la fermeture des fonctions pour implémenter des fonctions avec des "variables statiques"
Copiez le code comme suit: Function Fun ()
{
var v = 1;
fonction fun2 ()
{
++ v;
Document.Write (V);
document.write ("<br>");
retour v;
}
retourner fun2;
}
var func = fun ();
func (); // Sortie 2
func (); // Sortie 3
func (); // Sortie 4