Avant d'évoquer les concepts ci-dessus, je souhaite d'abord parler des paramètres implicites des fonctions en JavaScript : arguments
Arguments
Cet objet représente les paramètres de la fonction en cours d'exécution et de la fonction qui l'appelle.
[fonction.]arguments[n]
Fonction paramètre : options. Le nom de l’objet Function en cours d’exécution. n : option. Index de base 0 de la valeur du paramètre à transmettre à l'objet Function.
Description
Arguments est un objet caché créé en plus des paramètres spécifiés lors de l'appel d'une fonction. Les arguments sont un objet similaire à un tableau mais pas à un tableau. On dit qu'il est similaire à un tableau car il a les mêmes propriétés et méthodes d'accès qu'un tableau. La valeur du paramètre unique correspondant est accessible via des arguments[. n], et il a la longueur de l'attribut de longueur de tableau. De plus, l'objet arguments stocke les paramètres réellement passés à la fonction, sans se limiter à la liste de paramètres définie par la déclaration de fonction, et l'objet arguments ne peut pas être explicitement créé. L'objet arguments n'est disponible qu'au début de la fonction. L'exemple suivant détaille ces propriétés :
//Utilisation de l'objet arguments.
fonction ArgTest(a, b){
var i, s = "La fonction ArgTest attendue" ;
var numargs = arguments.length; // Récupère la valeur de l'argument passé.
var expargs = ArgTest.length; // Récupère la valeur du paramètre attendu.
si (expargs < 2)
s += expargs + "argument. ";
autre
s += expargs + " arguments. ";
si (nombres < 2)
s += numargs + " a été passé.";
autre
s += numargs + "ont été transmis.";
s += "nn"
for (i =0; i < numargs; i++){ // Récupère le contenu du paramètre.
s += " Arg " + i + " = " + arguments[i] + "n";
}
return(s); // Renvoie la liste des paramètres.
}
Ajout d'un code indiquant que les arguments ne sont pas un tableau (classe Array) :
Array.prototype.selfvalue = 1 ;
alert(new Array().selfvalue);
fonction testAguments(){
alert(arguments.selfvalue);
}
Exécutez le code et vous constaterez que la première alerte affiche 1, ce qui signifie que l'objet tableau a un attribut selfvalue avec une valeur de 1. Lorsque vous appelez la fonction testAguments, vous constaterez que "undefined" s'affiche, indiquant que ce n'est pas un attribut d'arguments. Autrement dit, arguments n'est pas un objet tableau.
demandeur
Renvoie une référence à la fonction qui a appelé la fonction actuelle.
functionName.caller
L'objet functionName est le nom de la fonction exécutée.
Notez que pour les fonctions, l'attribut caller n'est défini que lorsque la fonction est exécutée. Si la fonction est appelée depuis le niveau supérieur, l'appelant contient null. Si l'attribut caller est utilisé dans un contexte de chaîne, le résultat est le même que functionName.toString, c'est-à-dire que le texte décompilé de la fonction est affiché.
L'exemple suivant illustre l'utilisation de l'attribut caller :
// caller demo {
fonction appelantDemo() {
si (callerDemo.caller) {
var a= callerDemo.caller.toString();
alerte(a);
} autre {
alert("c'est une fonction top");
}
}
fonction handleCaller() {
callerDemo();
}
l'appelé
renvoie l'objet Function en cours d'exécution, qui est le corps de l'objet Function spécifié.
[fonction.]arguments.callee
Le paramètre facultatif de fonction est le nom de l’objet Function en cours d’exécution.
Notez que
la valeur initiale de l'attribut appelé est l'objet Function en cours d'exécution.
L'attribut callee est membre de l'objet arguments. Il représente une référence à l'objet fonction lui-même, ce qui est bénéfique pour la récursion des fonctions anonymes ou pour assurer l'encapsulation des fonctions. Par exemple, l'exemple suivant calcule de manière récursive la somme des fonctions naturelles. nombres de 1 à n. Cette propriété n'est disponible que lorsque la fonction appropriée est en cours d'exécution. Il convient également de noter que l'appelé possède un attribut de longueur, ce qui est parfois meilleur pour la vérification. arguments.length est la longueur réelle du paramètre et arguments.callee.length est la longueur du paramètre formel. À partir de là, vous pouvez déterminer si la longueur du paramètre formel est cohérente avec la longueur réelle du paramètre lors de l'appel.
Exemple
//l'appelé peut s'imprimer
fonction appeléeDemo() {
alert(arguments.callee);
}
//Utilisé pour vérifier les paramètres
fonction calleeLengthDemo (arg1, arg2) {
si (arguments.length==arguments.callee.length) {
window.alert("Vérifiez que les longueurs formelles et réelles des paramètres sont correctes!");
retour;
} autre {
alert("Longueur réelle du paramètre : " +arguments.length);
alert("Longueur du paramètre formel : " +arguments.callee.length);
}
}
//Calcul récursif
var somme = fonction(n){
si (n <= 0)
renvoyer 1 ;
autre
retourner n + arguments.callee(n - 1)
}
Une fonction récursive plus générale :
var sum = function(n){
si (1==n) renvoie 1 ;
sinon return n + sum (n-1);
Lors de l'appel : alert(sum(100));
La fonction contient une référence à sum elle-même. Le nom de la fonction est juste un nom de variable. Appeler sum à l'intérieur de la fonction équivaut à appeler une variable globale. Dans ce cas, l'utilisation de l'appelé sera un. comparaison. Bonne approche.
apply et call
servent à lier une fonction à un autre objet pour l'opération. La seule différence entre elles est la manière de définir les paramètres :
apply(thisArg,argArray);
call(thisArg[,arg1,arg2...] ]) ;
Autrement dit, le pointeur this à l'intérieur de toutes les fonctions se verra attribuer la valeur de thisArg, ce qui peut atteindre l'objectif d'exécuter la fonction en tant que méthode d'un autre objet.
L'explication d'Apply
est que si argArray n'est pas un tableau valide ou n'est pas un argument. objet, cela provoquera une TypeError.
Si ni argArray ni thisArg ne sont fournis, l'objet Global sera utilisé comme thisArg.
et aucun paramètre ne peut être transmis.
Description de l'appel
La méthode call modifie le contexte d'objet d'une fonction du contexte initial au nouvel objet spécifié par thisArg.
Si le paramètre thisArg n'est pas fourni, alors l'objet Global est utilisé comme thisArg.
Conseils associés :
Il existe une autre astuce pour appliquer call et apply pour appliquer une autre fonction (classe), la fonction actuelle (. classe) seront disponibles. Les méthodes ou propriétés d’une autre fonction (classe) peuvent également être appelées « héritage ». Regardez l'exemple suivant :
// Démonstration d'héritage
fonction base() {
this.member = "dnnsun_Member";
this.method = fonction() {
window.alert(ce.membre);
}
}
fonction étendre() {
base.call(this);
window.alert (membre);
window.alert(this.method);
}
Comme le montre l'exemple ci-dessus, extend peut hériter des méthodes et propriétés de base après son appel.
À propos, apply est utilisé dans le prototype du framework JavaScript pour créer un modèle
qui définit une classe. Le code d'implémentation est le suivant :
var Class = {.
créer : fonction() {
fonction de retour() {
this.initialize.apply(this, arguments);
}
}
}
Analyse : Du point de vue du code, cet objet ne contient qu'une seule méthode : Create, qui renvoie une fonction, c'est-à-dire une classe. Mais c'est aussi le constructeur de la classe, qui appelle initialize, et cette méthode est la fonction d'initialisation définie lors de la création de la classe. De cette façon,
Vous pouvez implémenter l'exemple du mode de création de classe dans le prototype
:
var Vehicle=Class.create();
véhicule.prototype={
initialiser:fonction(type){
this.type=type;
}
showSelf:fonction(){
alert("ce véhicule est "+ this.type);
}
}
var moto=nouveau véhicule("Moto");
moto.showSelf();
Pour des informations plus détaillées sur le prototype, veuillez visiter son site officiel.
http://www.cnblogs.com/sunwangji/archive/2006/08/21/482341.html