javascript - Concernant la réaffectation de la fonction elle-même au sein de l'IIFE nommé?

Question

{Code...} Je voudrais demander où sont passés les 10 qui ont été réaffectés à foo à l'intérieur de la fonction foo, et comment la fonction foo du même nom empêche la pollution mondiale. Veuillez le résoudre et le développer.

我想大声告诉你 · Answer

L’interlocuteur peut poser cette question, c’est très bien. Cependant, ce problème peut être résolu par la pratique. ．．

Tout d'abord, le questionneur n'a aucun problème avec la façon d'écrire IIFE. Il existe de nombreuses façons d'écrire IIFE Les plus courantes sont ce que @ewind a dit et :

.

(function(){}())

Il y en a aussi des plus rares :

!function(){ /* code */ }();
~function(){ /* code */ }();
-function(){ /* code */ }();
+function(){ /* code */ }();

Parlons ensuite du code :
Lors de l'attribution d'une valeur au nom de la fonction actuelle dans une fonction : foo = 10; Invalide. (Je suis d'accord avec @ewind, il sera ignoré ici. Il devrait y avoir une explication plus raisonnable.) L'analyseur JS l'ignorera.
Le résultatque j'ai exécuté dans la console Chrome est :

function foo(){
    foo=10;//我的问题代码
    console.log(foo);//方法自己
}
undefined　　// 上面typeof foo的结果

Cela prouve ce que j'ai dit ci-dessusignorer．
Ensuite, comme IIFE simule la portée du bloc, l'environnement externe ne peut pas accéder aux variables internes. Donc ce n'est pas défini.

＠ewind a dit que parce que foo est une fonction anonyme, alors quoi ?
Évidemment, les concepts sont confus. La fonction foo n'est pas une fonction anonyme.

function [name]([param] [, param] [..., param]) { statements }

name
函数名，可以省略。当省略函数名的时候，该函数就成为了匿名函数。

MDN

迷茫 · Answer

Tout d'abord, le code posté est incomplet. La version complète devrait être comme ça

(function foo(){
  foo = 10
  console.log(foo) // [Function: foo]
})();
console.log(typeof foo) // undefined

Cela semble contre-intuitif, car foo sans déclaration var ne pollue pas la portée globale.

Mais si le nom de la variable déclaré dans la fonction n'est pas foo, c'est très intuitif, de la manière suivante :

var bar = 1;

(function foo(){
  bar = 10
})();

console.log(typeof foo) // undefined
console.log(bar) // 10

Alors pourquoi un problème survient-il lorsque la variable déclarée dans la fonction porte le même nom que le nom de la fonction ? Vous pouvez voir cet exemple :

(function foo(){
  console.log(foo) // [Function: foo]
  console.log(arguments.callee) // [Function: foo]
  console.log(foo === arguments.callee) // true
})();

Une fois que la fonction immédiatement exécutée porte le nom de fonction foo, les arguments.callee lors de l'appel sont en fait une référence à foo. En comparant les deux, nous pouvons constater que foo est l'objet fonction à ce moment-là. À ce stade, l'opération d'affectation ne prendra pas effet. Lorsqu'il rencontrera la variable foo sans déclaration var, l'interpréteur trouvera également cet objet fonction, évitant ainsi la pollution dans la portée globale.