Les fonctions JavaScript sont différentes des autres langages. Chaque fonction est gérée et exécutée en tant qu'objet. Grâce aux propriétés des objets fonction, vous pouvez facilement attribuer une fonction à une variable ou transmettre la fonction en paramètre. Avant de continuer, examinons la syntaxe d'utilisation des fonctions :
Voici une citation :
fonction func1(…){…}
var func2=fonction(…){…};
var func3=fonction func4(…){…};
var func5=nouvelle fonction();
Copiez le code comme suit :
<script type="text/javascript">
// 1, mode d'appel de méthode
// Lorsqu'une fonction est enregistrée comme propriété d'un objet, nous l'appelons une méthode de l'objet, alors celle-ci est liée à l'objet
var monObjet={
nom : "monObjet",
valeur : 0,
incrément : fonction(num){
this.value += typeof(num) === 'numéro' ?
rends ceci ;
} ,
toString : fonction(){
return '[Object:' + this.name + '{value:' + this.value + '}]';
}
}
alert(myObject.increment(10).increment(20).toString()); // [Object:myObject {value:30}]
// 2, mode d'appel de fonction
// Lorsqu'une fonction n'est pas une fonction d'un objet, elle est appelée en tant que fonction, et celle-ci est liée à l'objet global. C'est une erreur dans la conception du langage. Si la conception du langage est correcte, lorsque la fonction interne est appelée, elle doit toujours être liée à la variable this de la fonction externe.
var monObjet={
nom : "monObjet",
valeur : 0,
incrément : fonction(num){
this.value += typeof(num) === 'numéro' ?
rends ceci ;
} ,
toString : fonction(){
return '[Object:' + this.name + '{value:' + this.value + '}]';
},
getInfo : fonction(){
var soi = ceci ;
retourner (fonction(){
//return this.toString(); // Ceci dans la fonction anonyme interne pointe vers la fenêtre d'objet globale et génère [object Window]
return self.toString(); // Définissez une variable selft et attribuez-lui la valeur this, puis la fonction interne peut accéder à ce pointage vers l'objet via cette variable
})();
}
}
alert(myObject.increment(10).increment(20).toString()); // [Object:myObject {value:30}]
// 3, mode d'appel du constructeur
// JavaScript est un langage basé sur l'héritage prototypique, ce qui signifie que les objets peuvent hériter des propriétés directement d'autres objets et que le langage est sans classe.
// Si une fonction est appelée avec new devant, un nouvel objet sera créé qui masquera le membre prototype connecté à la fonction, et celui-ci sera lié à l'instance du constructeur.
fonction MonObjet(nom){
this.name = nom || 'MonObjet';
this.value=0 ;
this.increment = fonction(num){
this.value += typeof(num) === 'numéro' ?
} ;
this.toString = fonction(){
return '[Object:' + this.name + '{value:' + this.value + '}]';
}
ceci.cible = ceci ;
}
MonObjet.prototype.getInfo = function(){
renvoie this.toString();
}
// Crée un objet MyObject.prototype en même temps. myObject hérite de toutes les propriétés de MyObject.prototype. Ceci est lié à l'instance de MyObject.
var monObjet = new MonObjet();
monObjet.increment(10);
alerte(monObjet.valeur); //10
var autreObjet = new MonObjet();
autreObject.increment(20);
alerte(autreObjet.valeur); //20
alert(monObjet.target===monObjet); // vrai
alert(myObject.target.getInfo()); // [Objet:MonObjet {valeur:10}]
// 4, Appliquer le mode d'appel
// JavaScript est un langage de programmation fonctionnel orienté objet, les fonctions peuvent donc avoir des méthodes. La méthode apply de la fonction est comme si l'objet avait cette méthode, et cela pointe vers l'objet.
// apply reçoit deux paramètres, le premier est l'objet à lier (l'objet pointé par celui-ci) et le second est le tableau de paramètres.
fonction MonObjet(nom){
this.name = nom || 'MonObjet';
cette.valeur = 0 ;
this.increment = fonction(num){
this.value += typeof(num) === 'numéro' ?
} ;
this.toString=fonction(){
return '[Object:'+this.name+' {value:'+this.value+'}]';
}
this.target=ce ;
}
fonction getInfo(){
renvoie this.toString();
}
var monObj = new MonObjet();
alert(getInfo.apply(myObj)); //[Object:MyObject {value:0}], cela pointe vers myObj
alert(getInfo.apply(window)); //[object Window], cela pointe vers la fenêtre
// pendant et pendant
fonction fonction(a,b){
alerte(a); // 1
alerte(b); // 2
pour(var i=0;i<arguments.length;i++){
alerte(arguments[i]); // 1, 2, 1, 2, 3
}
var je = 0 ;
while(i<arguments.longueur){
alerte(arguments[i]); // 1, 2, 1, 2, 3
je = je + 1 ;
}
}
fonction(1,2,3);
var je = 0
pour (i=0;i<=10;i++) {
document.write("Le numéro est " + i + "<br/>")
}
</script>