function f1(){//2、找到 f1 函數(shù),執(zhí)行。
var n=999;//3、給變量 n 賦值。
nAdd=function(){n+=1}//9、找到 nAdd ,匿名函數(shù)內(nèi)沒有變量 n ,需要去上層查找,n = 999 +1。
function f2(){//5、找到 f2 函數(shù),執(zhí)行。
alert(n);//6、執(zhí)行動(dòng)作。
}
console.log(n);//新加上,測試,不參與執(zhí)行步驟。
return f2;//4、返回 f2 函數(shù),需要尋找 f2 函數(shù)。
}
var result=f1();//1、將 f1函數(shù)的返回值賦值給 result 變量,result 也變成函數(shù),需要尋找f1函數(shù)。
result(); //7、第一次執(zhí)行 result 函數(shù),將步驟 6 的執(zhí)行動(dòng)作(步驟 6)結(jié)果輸出,n 等于 999。
nAdd();//8、執(zhí)行 f1 函數(shù)里的全局變量函數(shù) nAdd ,需要尋找 nAdd 函數(shù)。
result(); //10、第二次執(zhí)行 result 函數(shù),將步驟 5 的執(zhí)行動(dòng)作(步驟 6)結(jié)果輸出,此時(shí) n 等于 1000,因?yàn)榈谝淮螆?zhí)行 result 函數(shù)時(shí),查找了上層的作用域,n 是 999。
nAdd();//11、如果再執(zhí)行 nAdd 函數(shù),此時(shí) nAdd 這個(gè)函數(shù)里的 n 是 1000,而 f1 函數(shù)的 n 還是 999,也就是說 f1 的變量 n 和 nAdd 的 n 是兩個(gè)作用域不同的同名變量。
result();
f1();//新加上,測試
/*結(jié)果
控制臺輸出:999
彈窗:999
彈窗:1000
彈窗:1001
控制臺輸出:999
*/
Je voudrais demander aux seniors de voir si cette compréhension est correcte.
Supplément?: peut-on comprendre que lorsque la fermeture est exécutée pour la première fois, elle doit rechercher la variable dans la couche supérieure. Après l'avoir trouvée, la valeur de la variable dans la couche supérieure devient la valeur de la variable de la sous-fonction. , et il n'est pas nécessaire de chercher à nouveau dans la couche supérieure car il a été hérité lors de la première exécution et devient le v?tre.
C'est un peu compliqué. . .
(couvre-visage
------------------------Ajouté à nouveau----------------------- -
Plus je le regarde, plus cela devient déroutant.
Ensuite, ce fut un désastre complet.
à en juger par les résultats de sortie, la première sortie de console et la dernière sortie de console, n de f1 est immuable.
Mais les sous-fonctions ne peuvent-elles pas lire les variables les unes des autres?? Pourquoi l’expression de nAdd affecte-t-elle n de f2??
擁有18年軟件開發(fā)和IT教學(xué)經(jīng)驗(yàn)。曾任多家上市公司技術(shù)總監(jiān)、架構(gòu)師、項(xiàng)目經(jīng)理、高級軟件工程師等職務(wù)。 網(wǎng)絡(luò)人氣名人講師,...
function f1(){
var n=999;
nAdd=function(){n+=1}
function f2(){
alert(n);
}
console.log(n);
return f2;
}
var result=f1();
result();
nAdd();
result();
nAdd();
result();
var b = f1();//新加上,測試
Pour le moment, b et n dans le résultat ne sont pas les mêmes
b et n dans nAdd sont les mêmes
Le n dans le résultat ne peut pas être modifié
J'ai la même question, j'ai donc copié ma réponse et en ai ajouté d'autres.
var result=f1()
?: La fonction f1 renvoie la fonction f2 var result=f1()
:f1函數(shù)返回了f2函數(shù)
把返回的f2函數(shù)賦值給result全局變量,(f2的作用域鏈保存到result全局變量中)
result()
:調(diào)用result(),這就形成閉包:有權(quán)訪問另外一個(gè)函數(shù)作用域中的變量
因?yàn)樵趂2中的作用域引用了f1中的n這個(gè)局部變量,當(dāng)f1執(zhí)行完畢后,垃圾回收機(jī)制發(fā)現(xiàn)n變量還在被result中引用所以垃圾回收機(jī)制不會把n回收釋放。
以至于n一直保存在result作用域鏈中。result的作用域鏈正常能訪問f1中的局部變量n,形成閉包。
nAdd()
:nAdd沒有寫var所以nAdd是全局變量,在調(diào)用nAdd()和result()是一樣的都會形成閉包,匿名函數(shù)function(){n+=1}的作用域鏈中有n這個(gè)局部變量,所以當(dāng)nAdd=funtion(){n+=1}時(shí),這個(gè)匿名函數(shù)的作用域鏈保存到了全局變量nAdd形成閉包,調(diào)用nAdd()作用域鏈中找到f1局部變量n=999,n+1=1000。
result()
Attribuez la fonction f2 renvoyée à la variable globale de résultat,
result()
?: Appelez result(), qui forme une fermeture?:
nAdd()
?: nAdd n'écrit pas var, donc nAdd est une variable globale. L'appel de nAdd() et result() est le même et formera une fermeture. La fonction anonyme function(){. n+=1} Il y a une variable locale n dans la cha?ne de portée, donc lorsque nAdd=function(){n+=1}, la cha?ne de portée de cette fonction anonyme est enregistrée dans la variable globale nAdd pour former une fermeture, qui est trouvée dans la cha?ne de portée en appelant la variable locale nAdd() f1 n=999, n+1=1000.
result()
?: result() génère 1000
nAdd(); Répétez la troisième étape n+1 = 1001
??result(); Répétez la quatrième étape et affichez n???? ????f1(); Aucune fermeture n'est formée lorsque f1 est appelé, n est toujours 999, car n est détruit par le mécanisme de récupération de place après chaque exécution de f1, donc var n=999 est à nouveau appelé ici ; Il est 999???? ?? ????Pourquoi l'expression de nAdd affecte-t-elle n de f2?? ???? En raison de la fermeture, n n'a jamais été détruit. nAdd() a également formé une fermeture et a modifié la valeur de n, donc result() est rappelé plus tard, n n'a pas été détruit et le recyclage a été +1, donc. ce sera l'Influence. ?? Enfin, il n'y a pas de fermeture lorsque f1() est appelé, et n a été détruit auparavant. Donc, il affiche toujours a=999;?? ????Ceci n'est que ma compréhension, s'il y a des erreurs, n'hésitez pas à me le faire savoir????Je vous suggère de lire ceci
http://www.ruanyifeng.com/blo...
C'est expliqué plus clairement
C'est trop compliqué à dire
Cette fermeture utilise la fonctionnalité de portée statique de js pour obtenir cet effet
function f1(){
var n=999;// 這里標(biāo)識n 為代號 n1
nAdd=function(){n+=1}+1。
function f2(){
alert(n);
}
console.log(n);
return f2;
}
var result=f1();
result();
nAdd();
result();
nAdd();
result();
f1();
Le premier appel à result()?:
alert(n); recherche le n1
nAdd(); ajoute également la valeur de n1
Il en va de même pour ceux qui sont derrière
Et le dernier f1();
Lors de l'exécution, var n = 999?; attribue une valeur à n1
Le n de console.log(n) est également n1, donc la valeur imprimée est 999
Votre exemple est un peu simple. Vous pouvez regarder un exemple complexe (concentrez-vous sur la description de la portée statique) :
portée statique