Mots-clés : arguments, appelé, appelant
arguments : représente les paramètres passés dans la fonction
appelé : instruction représentant des fonctions et des corps de fonctions
caller : représente la fonction qui appelle la fonction
arguments
Cet objet représente la fonction en cours d'exécution et les paramètres de la fonction qui l'appelle.
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 en cours d'exécution.
illustrer
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, alors 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é.
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.
illustrer
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 associé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.
Copiez le code comme suit :
<script type='text/javascript'>
test de fonction (x, y, z)
{
alert("Longueur réelle du paramètre :"+arguments.length);
alert("Longueur du paramètre formel :"+arguments.callee.length);
alert("Longueur du paramètre formel :"+test.length);
alerte(arguments[ 0 ])
alert(test[ 0 ]) // undefined n'a pas une telle utilisation
}
//test(1,2,3);
tester(1,2,3,4);
/*
* les arguments ne sont pas un tableau (classe Array)
*/
Array.prototype.selfvalue = 1 ;
fonction testAguments() {
alert( " arguments.selfvalue= " + arguments.selfvalue);
}
alert("Array.sefvalue="+new Array().selfvalue);
testAguments();
/**/ /*
* Démontre l'attribut appelant de la fonction.
* Description : (fonction actuelle).caller : renvoie une référence à la fonction qui a appelé la fonction actuelle.
*/
fonction appelantDemo() {
si (callerDemo.caller) {
var a = callerDemo.caller.arguments[ 0 ];
alerte(a);
} autre {
alert( " ceci est une fonction top " );
}
}
fonction handleCaller() {
callerDemo();
}
callerDemo();
handleCaller("Paramètre 1", "Paramètre 2");
/**/ /*
* Démontre l'attribut appelé de la fonction.
* Description : arguments.callee : la valeur initiale est l'objet Function en cours d'exécution, utilisé pour les fonctions anonymes
*/
fonction appeléeDemo() {
alert(arguments.callee);
}
appeléDemo();
(function(arg0,arg1){alert("Le nombre de formes est : "+arguments.callee.length)})();
/**/ /*
* Démontrer l'utilisation des fonctions d'application et d'appel
* Remarque : La fonction consiste à lier la fonction à un autre objet à exécuter. La seule différence entre les deux est la manière de définir les paramètres :
* appliquer(thisArg,argArray);
* appeler(thisArg[,arg1,arg2…] ]);
* Autrement dit, le pointeur this à l'intérieur de toutes les fonctions se verra attribuer thisArg
*/
fonctionObjetA() {
alert( "Exécuter ObjectA() " );
alerte(arguments[ 0 ]);
this .hit = function (msg) {alerte (msg)}
this .info = "Je viens d'ObjectA"
}
fonctionObjetB() {
alert( "Exécuter ObjectB() " );
// Appelez la méthode ObjectA(), et tout cela dans le constructeur ObjectA sera remplacé par this dans ObjectB.
ObjectA.apply(this,arguments); // ObjectA.call(this);
alerte (ce .info);
}
ObjectB('Paramètre 0');
var valeur = "variable globale" ;
fonction Obj() {
this .value = "Objet !";
}
fonction Fun1() {
alert(ce .value);
}
Amusant1();
Fun1.apply(fenêtre);
Fun1.apply(nouvel Obj());
</script>