Explication détaillée de l'appelant et de l'appelé dans les compétences javascript_javascript

J'ai récemment appris JavaScript et j'ai rencontré des problèmes avec l'appelant et l'appelé, je suis donc souvent allé sur Baidu en ligne. Le contenu trouvé est d’une grande utilité pour tout le monde. Je l’ai compilé et résumé pour le partager avec vous.

caller : renvoie une référence à la fonction qui appelle la fonction function (utilisation : function.caller)

Remarque : Pour les fonctions, l'attribut de l'appelant 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 est nul.

var time = 3 //控制次数，去掉会一直在caller与handleCaller交替不断执行
function caller() {
  caller.caller()//返回调用caller函数的函数引用
}
function handleCaller() {
  if (time > 0){
    time--
    alert(handleCaller.caller)//返回调用handleCaller函数的函数引用
    alert(caller.caller)//返回调用caller函数的函数引用
    caller()
  }
}
handleCaller()

Exemple d'analyse : lorsque handleCaller est exécuté pour la première fois, les deux alertes renvoient null alert(handleCaller.caller) renvoie null car il est appelé depuis le niveau supérieur, et alert(caller.caller) renvoie null car caller La valeur par défaut. la valeur est nulle. Ensuite, la fonction caller() est appelée. caller.caller renvoie une référence à la fonction qui l'a appelée (handleCaller). La fonction handleCaller peut être appelée à nouveau via caller.caller(). Lorsque handleCaller s'exécute pour la deuxième fois, alert(handleCaller.caller) renvoie le code de l'appelant (en fait une référence à l'appelant) et alert(caller.caller) renvoie le code handleCaller. Parce que la relation d'appel entre les fonctions est handleCaller->caller->handleCaller. Après cela, il continuera à alterner entre les deux fonctions.

l'appelant pointe vers la fonction qui appelle la fonction actuelle, mais il y a une chose. S'il est appelé dans la portée globale (c'est-à-dire la fenêtre de niveau supérieur), null sera renvoyé.
Le code démarre

====================
function testCaller(){
if(testCaller.caller == null){
console.log('accessed at global');
}else{
console.log('accessed at ' + testCaller.caller);
}
}

Appelez dans le monde entier

testCaller(); // accessed at global

Appel
dans une fonction

function a(){
testCaller();
}
a(); // accessed at function a(){testCaller();} 

À ce moment, testCaller.caller pointe vers la fonction a

appelé : Renvoie la référence de fonction des arguments correspondants. (Principalement utilisé pour la récursion de fonctions anonymes)

Remarque : ce que vous voyez peut-être le plus sur Internet, c'est que l'appelé renvoie une référence à la fonction en cours d'exécution. C'est ainsi que je le comprends. Chaque fonction a ses propres arguments, qui sont généralement utilisés pour stocker les paramètres. arguments a un attribut d'appelé et la valeur initiale est la référence de fonction qui lui correspond. Lorsque votre fonction exécute cette instruction, les arguments correspondent par défaut à la fonction que vous exécutez actuellement, puis arguments.callee est une référence à la fonction en cours d'exécution. Bien sûr, si vous avez marqué les arguments d'autres fonctions (args dans l'exemple), vous pouvez naturellement utiliser args.callee() pour appeler à nouveau cette fonction.

function a(){
  alert(arguments.callee)
  var args = arguments
  function c(){
    alert(arguments.callee)
    args.callee()
  }
  c()
}
a()

Exemple d'analyse : arguments.callee dans l'exemple renvoie une référence à la fonction en cours d'exécution par défaut (a renvoie la propre référence de fonction de a, c renvoie la propre référence de fonction de c), et en utilisant args pour stocker les arguments d'une fonction, utilisez args.callee() dans la fonction intégrée c pour appeler à nouveau la fonction a.

====================
function a(x){

if(x<=1)
return x;
else
return x + a(x-1);
}
a(12) // 78

Il s'agit d'une récursion minimaliste avec des résultats normaux.

Jetez un œil à la méthode d'appel ci-dessous

var b = a;
a = null; // 将a回收
b(12); // erro : 'a' is not a function

La raison est également simple, b=a, b=function a(){}; avant d'appeler b, nous avons utilisé a=null. Ainsi, lorsque la fonction a est en cours d'exécution, a en retour x a(x-1); pointe vers null, pas vers la fonction a.
J'ai donc signalé une erreur, comment résoudre ce problème. Changeons un pour une autre manière

function a(x){
if(x<=1)
return x;
else
return arguments.callee(x-1); // 这句是改变的地方
}

Rappelez

var b = a;
a = null;
b(12); // 78

Raison : bien que nous ayons défini a=null, a n'est pas utilisé dans la fonction a, mais pointe vers la fonction actuelle via arguments.callee.
Parce que la définition de arguments.callee est : renvoie la fonction en cours d’exécution.