diff --git a/README.md b/README.md index b203a060..c96b660c 100644 --- a/README.md +++ b/README.md @@ -104,9 +104,9 @@ for (let i = 0; i < 3; i++) { #### Answer: C -Because of the event queue in JavaScript, the `setTimeout` callback function is called _after_ the loop has been executed. Since the variable `i` in the first loop was declared using the `var` keyword, this value was global. During the loop, we incremented the value of `i` by `1` each time, using the unary operator `++`. By the time the `setTimeout` callback function was invoked, `i` was equal to `3` in the first example. +Because of the event queue in JavaScript, the `setTimeout` callback function is called _after_ the loop has been executed. Since the variable `i` in the first loop was declared using the `var` keyword, this value was global. During the loop, we incremented the value of `i` by `1` each time, using the unary operator `++`. By the time the `setTimeout` callback function was invoked, `i` was equal to `3` in the first example. Due to hoisting, `var` allocates a single memory slot for the variable, so each iteration overwrites the same variable rather than creating a new one. -In the second loop, the variable `i` was declared using the `let` keyword: variables declared with the `let` (and `const`) keyword are block-scoped (a block is anything between `{ }`). During each iteration, `i` will have a new value, and each value is scoped inside the loop. +In the second loop, the variable `i` was declared using the `let` keyword: variables declared with the `let` (and `const`) keyword are block-scoped (a block is anything between `{ }`). During each iteration, `i` will have a new value, and each value is scoped inside the loop. Unlike `var`, `let` creates a new binding (a new memory slot) for each iteration, which is why each `setTimeout` callback captures a different value.

diff --git a/ar-AR/README_AR.md b/ar-AR/README_AR.md index ace6ed98..7a767030 100644 --- a/ar-AR/README_AR.md +++ b/ar-AR/README_AR.md @@ -98,8 +98,8 @@ for (let i = 0; i < 3; i++) {
الإجابة هي الخيار الثالث: C -بسبب ترتيب تسلسل الأحداث في الجافا سكريبت, دالة `setTimeout` والتي هي دالة من نوع callbackقد تم استدعائها بعد ان تم تنفيذ ال loop. بماأن المتغير `i` في الloop الاولى قد تم تعريفه عن طريق الكلمة المفتاحية `var` فإن هذه القيمة هي global. أثناء تنفيذ هذه ال loop قد تم إضافة 1 الى المتغير `var` في كل دورة باستخدام العملية `++`. بنهاية الدورة و عندما تم استدعاء الدالة `setTimeout` كانت قيمة المتغير `i` قد أصبحت تساوي `3` في المثال الأول. -في الloop الثانية ,تم تعريف المتغير `i` باستخدام الكلمة المفتاحية `let` المتغيرات التي يتم تعريفها باستخدام الكلمات المفتاحية `let` و `const` هي متغيرات تنتمي فقط للBlock الذي تم تعريفها بداخله, والذي هو بين القوسين, أثناءتنفيذ الloop, سنقوم بالتحصل على قيمة جديدة للمتغير `i` في نهاية كل دورة , وأي قيمة تكون منتمية للScope بداخل الloop. +بسبب ترتيب تسلسل الأحداث في الجافا سكريبت, دالة `setTimeout` والتي هي دالة من نوع callbackقد تم استدعائها بعد ان تم تنفيذ ال loop. بماأن المتغير `i` في الloop الاولى قد تم تعريفه عن طريق الكلمة المفتاحية `var` فإن هذه القيمة هي global. أثناء تنفيذ هذه ال loop قد تم إضافة 1 الى المتغير `var` في كل دورة باستخدام العملية `++`. بنهاية الدورة و عندما تم استدعاء الدالة `setTimeout` كانت قيمة المتغير `i` قد أصبحت تساوي `3` في المثال الأول. بسبب الـ hoisting، `var` يخصص مساحة ذاكرة واحدة للمتغير، لذلك كل تكرار يعيد كتابة نفس المتغير بدلاً من إنشاء متغير جديد. +في الloop الثانية ,تم تعريف المتغير `i` باستخدام الكلمة المفتاحية `let` المتغيرات التي يتم تعريفها باستخدام الكلمات المفتاحية `let` و `const` هي متغيرات تنتمي فقط للBlock الذي تم تعريفها بداخله, والذي هو بين القوسين, أثناءتنفيذ الloop, سنقوم بالتحصل على قيمة جديدة للمتغير `i` في نهاية كل دورة , وأي قيمة تكون منتمية للScope بداخل الloop. على عكس `var`، `let` ينشئ ربطاً جديداً (مساحة ذاكرة جديدة) لكل تكرار، ولهذا السبب كل callback لـ `setTimeout` يلتقط قيمة مختلفة.

diff --git a/ar-EG/README_ar-EG.md b/ar-EG/README_ar-EG.md index b9024d95..3c618097 100644 --- a/ar-EG/README_ar-EG.md +++ b/ar-EG/README_ar-EG.md @@ -68,9 +68,9 @@ for (let i = 0; i < 3; i++) { #### الاجابة: ج -الفنكشن اللي`setTimeout` بتشغلها بيتم تشغليها _بعد_ ما اللووب تخلص بسبب قائمة الاحداث `event queue` في جافاسكربت. بما ان اول لووب اتعملت كان المتغير بتاعها معمول بكلمة `var` اذا كان `global` وبالتالي في اللوب احنا كل شوية كنا بنزود `i` لحد ما وصل ل 3 و _بعد_ كده قامت الفنكشن اللي جوا `setTimeout` اشتغلت. ده كده اول لووب. +الفنكشن اللي`setTimeout` بتشغلها بيتم تشغليها _بعد_ ما اللووب تخلص بسبب قائمة الاحداث `event queue` في جافاسكربت. بما ان اول لووب اتعملت كان المتغير بتاعها معمول بكلمة `var` اذا كان `global` وبالتالي في اللوب احنا كل شوية كنا بنزود `i` لحد ما وصل ل 3 و _بعد_ كده قامت الفنكشن اللي جوا `setTimeout` اشتغلت. ده كده اول لووب. بسبب الـ hoisting، `var` بيخصص مساحة ذاكرة واحدة للمتغير، فكل تكرار بيعيد كتابة نفس المتغير بدل ما يعمل متغير جديد. -اما بقى في تاني لووب المتغير `i` كان معمول بكلمة `let` و بالتالي المنظور بتاعه `scope` محدد بالاقواس المحيطة بيه `block` وبالتالي في كل مره اللوب هتزيد هيكون في قيمة جديدة تماماً للمتغير `i` و كل قيمة من دول موجوده جوا ال`block scope` اللي هي حصلت فيه, و بالتالي هيبقى كأن البرنامج شايف 3 قيم للمتغير `i` في 3 اماكن مختلفه! +اما بقى في تاني لووب المتغير `i` كان معمول بكلمة `let` و بالتالي المنظور بتاعه `scope` محدد بالاقواس المحيطة بيه `block` وبالتالي في كل مره اللوب هتزيد هيكون في قيمة جديدة تماماً للمتغير `i` و كل قيمة من دول موجوده جوا ال`block scope` اللي هي حصلت فيه, و بالتالي هيبقى كأن البرنامج شايف 3 قيم للمتغير `i` في 3 اماكن مختلفه! عكس `var`، `let` بيعمل ربط جديد (مساحة ذاكرة جديدة) لكل تكرار، وعلشان كده كل callback بتاع `setTimeout` بيلتقط قيمة مختلفة.

diff --git a/bs-BS/README-bs_BS.md b/bs-BS/README-bs_BS.md index 33f0384f..0200a7ae 100644 --- a/bs-BS/README-bs_BS.md +++ b/bs-BS/README-bs_BS.md @@ -105,12 +105,12 @@ varijabla `i` u prvoj petlji je deklarirana pomoću ključne riječi` var`, ta je vrijednost bila globalna. Tijekom petlje povećavamo vrijednost `i` svaki put '1', koristeći unarni operator `++`. Do vremena Pozvana je function povratnog poziva `setTimeout`,` i` je bila jednaka `3` u -u prvom primjeru. +u prvom primjeru. Zbog hoistinga, `var` dodjeljuje jedan memorijski slot za varijablu, tako da svaka iteracija prepisuje istu varijablu umjesto da stvara novu. U drugoj petlji, varijabla `i` je deklarirana pomoću` let` ključna riječ: varijable deklarirane s ključnom riječi `let` (i` const`) su block-scoped (blok je sve između `{}`). Tijekom svake iteracije, -`i` će imati novu vrijednost, a svaka vrijednost će biti obuhvaćena unutar petlje. +`i` će imati novu vrijednost, a svaka vrijednost će biti obuhvaćena unutar petlje. Za razliku od `var`, `let` stvara novo vezivanje (novi memorijski slot) za svaku iteraciju, zbog čega svaki `setTimeout` callback hvata drugu vrijednost.

diff --git a/de-DE/README.md b/de-DE/README.md index 0ac8c271..ecdd58f0 100644 --- a/de-DE/README.md +++ b/de-DE/README.md @@ -103,9 +103,9 @@ for (let i = 0; i < 3; i++) { #### Antwort: C -Aufgrund der Event Queue in JavaScript, wird die Callback Funktion in `setTimeout` _nach_ der Schleife ausgeführt. Da die Variable `i` in der ersten Schleife mit dem `var` Keyword definiert wurde, ist dieser Wert global verfügbar. Während der Schleife wird der Wert von `i` jedesmal mithilfe des `++` Operators um `1` erhöht. Zu dem Zeitpunkt, wenn die Callback Funktion in `setTimeout` aufgerufen wird, ist `i` gleich `3` im ersten Beispiel. +Aufgrund der Event Queue in JavaScript, wird die Callback Funktion in `setTimeout` _nach_ der Schleife ausgeführt. Da die Variable `i` in der ersten Schleife mit dem `var` Keyword definiert wurde, ist dieser Wert global verfügbar. Während der Schleife wird der Wert von `i` jedesmal mithilfe des `++` Operators um `1` erhöht. Zu dem Zeitpunkt, wenn die Callback Funktion in `setTimeout` aufgerufen wird, ist `i` gleich `3` im ersten Beispiel. Aufgrund des Hoistings reserviert `var` einen einzigen Speicherplatz für die Variable, sodass jede Iteration dieselbe Variable überschreibt, anstatt eine neue zu erstellen. -In der zweiten Schleife wurde die Variable `i` mit dem `let` Keyword definiert: Variablen, die mit `let` (oder `const`) deklariert werden sind block-scoped (Ein Block ist alles zwischen `{ }`). Während jedem Durchlauf bekommt `i` einen neuen Wert zugewiesen, der jeweils innerhalb des Scopes der Schleife liegt. +In der zweiten Schleife wurde die Variable `i` mit dem `let` Keyword definiert: Variablen, die mit `let` (oder `const`) deklariert werden sind block-scoped (Ein Block ist alles zwischen `{ }`). Während jedem Durchlauf bekommt `i` einen neuen Wert zugewiesen, der jeweils innerhalb des Scopes der Schleife liegt. Im Gegensatz zu `var` erstellt `let` bei jeder Iteration eine neue Bindung (einen neuen Speicherplatz), weshalb jeder `setTimeout`-Callback einen anderen Wert erfasst.

diff --git a/es-ES/README-ES.md b/es-ES/README-ES.md index e839d901..977f07f6 100644 --- a/es-ES/README-ES.md +++ b/es-ES/README-ES.md @@ -90,9 +90,9 @@ for (let i = 0; i < 3; i++) { #### Respuesta correcta: C -Debido a la cola de eventos en JavaScript, la función `setTimeout` se llama una vez el ciclo se ha ejecutado. Dado que la variable `i` en el primer bucle se declaró utilizando la palabra reservada ` var`, este valor es global. Durante el bucle, incrementamos el valor de `i` en` 1` cada vez, utilizando el operador unario `++`. Cuando se invocó la función `setTimeout`,` i` era igual a `3` en el primer ejemplo. +Debido a la cola de eventos en JavaScript, la función `setTimeout` se llama una vez el ciclo se ha ejecutado. Dado que la variable `i` en el primer bucle se declaró utilizando la palabra reservada ` var`, este valor es global. Durante el bucle, incrementamos el valor de `i` en` 1` cada vez, utilizando el operador unario `++`. Cuando se invocó la función `setTimeout`,` i` era igual a `3` en el primer ejemplo. Debido al hoisting, `var` asigna una única ranura de memoria para la variable, por lo que cada iteración sobrescribe la misma variable en lugar de crear una nueva. -En el segundo bucle, la variable `i` se declaró utilizando la palabra reservada` let`: las variables declaradas con la palabra reservada `let` (y` const`) tienen un ámbito de bloque (un bloque es lo que se encuentra entre `{}`). Durante cada iteración, `i` tendrá un nuevo valor, y cada valor se encuentra dentro del bucle. +En el segundo bucle, la variable `i` se declaró utilizando la palabra reservada` let`: las variables declaradas con la palabra reservada `let` (y` const`) tienen un ámbito de bloque (un bloque es lo que se encuentra entre `{}`). Durante cada iteración, `i` tendrá un nuevo valor, y cada valor se encuentra dentro del bucle. A diferencia de `var`, `let` crea un nuevo enlace (una nueva ranura de memoria) en cada iteración, por lo que cada callback de `setTimeout` captura un valor diferente.

diff --git a/fr-FR/README_fr-FR.md b/fr-FR/README_fr-FR.md index 16d0d14e..228f1880 100644 --- a/fr-FR/README_fr-FR.md +++ b/fr-FR/README_fr-FR.md @@ -84,9 +84,9 @@ for (let i = 0; i < 3; i++) { #### Réponse : C -À cause du système de queue dans JavaScript, la fonction de rappel _(callback)_ du `setTimeout` est appelée _après_ que la boucle soit exécutée. Comme la variable `i` dans la première boucle est déclarée avec le mot-clé `var`, c'est une variable globale. Pendant la boucle, nous incrémentons la valeur de `i` de `1` à chaque fois, en utilisant l'opérateur arithmétique `++`. Lorsque la fonction de rappel _(callback)_ du `setTimeout` est invoquée, `i` est égal à `3` dans le premier exemple. +À cause du système de queue dans JavaScript, la fonction de rappel _(callback)_ du `setTimeout` est appelée _après_ que la boucle soit exécutée. Comme la variable `i` dans la première boucle est déclarée avec le mot-clé `var`, c'est une variable globale. Pendant la boucle, nous incrémentons la valeur de `i` de `1` à chaque fois, en utilisant l'opérateur arithmétique `++`. Lorsque la fonction de rappel _(callback)_ du `setTimeout` est invoquée, `i` est égal à `3` dans le premier exemple. En raison du hoisting, `var` alloue un seul emplacement mémoire pour la variable, donc chaque itération écrase la même variable au lieu d'en créer une nouvelle. -Dans la seconde boucle, la variable `i` est déclarée avec le mot clé `let` : les variables déclarées avec `let` (et `const`) ont une portée de bloc (tout ce qui est entre `{ }` est considéré comme un bloc). Pendant chaque itération, `i` aura une nouvelle valeur, et chaque valeur sera définie dans la boucle. +Dans la seconde boucle, la variable `i` est déclarée avec le mot clé `let` : les variables déclarées avec `let` (et `const`) ont une portée de bloc (tout ce qui est entre `{ }` est considéré comme un bloc). Pendant chaque itération, `i` aura une nouvelle valeur, et chaque valeur sera définie dans la boucle. Contrairement à `var`, `let` crée une nouvelle liaison (un nouvel emplacement mémoire) à chaque itération, c'est pourquoi chaque callback `setTimeout` capture une valeur différente.

diff --git a/id-ID/README.md b/id-ID/README.md index 2f238d06..adf43999 100644 --- a/id-ID/README.md +++ b/id-ID/README.md @@ -96,9 +96,9 @@ for (let i = 0; i < 3; i++) { #### Jawaban: C -Karena antrean peristiwa di JavaScript, fungsi callback `setTimeout` disebut _after_ loop telah dijalankan. Karena variabel `i` di loop pertama dideklarasikan menggunakan kata kunci` var`, nilai ini adalah global. Selama perulangan, kita menambah nilai `i` sebesar `1` setiap kali, menggunakan operator unary` ++ `. Pada saat fungsi callback `setTimeout` dipanggil,` i` sama dengan `3` di contoh pertama. +Karena antrean peristiwa di JavaScript, fungsi callback `setTimeout` disebut _after_ loop telah dijalankan. Karena variabel `i` di loop pertama dideklarasikan menggunakan kata kunci` var`, nilai ini adalah global. Selama perulangan, kita menambah nilai `i` sebesar `1` setiap kali, menggunakan operator unary` ++ `. Pada saat fungsi callback `setTimeout` dipanggil,` i` sama dengan `3` di contoh pertama. Karena hoisting, `var` mengalokasikan satu slot memori untuk variabel, sehingga setiap iterasi menimpa variabel yang sama daripada membuat yang baru. -Pada perulangan kedua, variabel `i` dideklarasikan menggunakan kata kunci` let`: variabel yang dideklarasikan dengan kata kunci `let` (dan` const`) memiliki cakupan blok (blok adalah apa saja di antara `{}`). Selama setiap iterasi, `i` akan memiliki nilai baru, dan setiap nilai dicakup di dalam loop. +Pada perulangan kedua, variabel `i` dideklarasikan menggunakan kata kunci` let`: variabel yang dideklarasikan dengan kata kunci `let` (dan` const`) memiliki cakupan blok (blok adalah apa saja di antara `{}`). Selama setiap iterasi, `i` akan memiliki nilai baru, dan setiap nilai dicakup di dalam loop. Tidak seperti `var`, `let` membuat binding baru (slot memori baru) untuk setiap iterasi, itulah sebabnya setiap callback `setTimeout` menangkap nilai yang berbeda.

diff --git a/it-IT/README.md b/it-IT/README.md index 13e465c6..deba21f5 100644 --- a/it-IT/README.md +++ b/it-IT/README.md @@ -107,9 +107,9 @@ for (let i = 0; i < 3; i++) { #### Risposta: C -A causa della coda degli eventi in JavaScript la funzione di callback `setTimeout` viene chiamata _dopo_ che il loop è stato eseguito. Poiché la variabile `i` nel primo loop è stata dichiarata usando la chiave `var`, questo valore è globale. Durante il loop abbiamo incrementato ogni volta il valore di `i` di `1` usando l'operatore unario `++`. Quando è stata invocata la funzione di callback `setTimeout`, `i` nel primo esempio risultava sin dal principio uguale a `3`. +A causa della coda degli eventi in JavaScript la funzione di callback `setTimeout` viene chiamata _dopo_ che il loop è stato eseguito. Poiché la variabile `i` nel primo loop è stata dichiarata usando la chiave `var`, questo valore è globale. Durante il loop abbiamo incrementato ogni volta il valore di `i` di `1` usando l'operatore unario `++`. Quando è stata invocata la funzione di callback `setTimeout`, `i` nel primo esempio risultava sin dal principio uguale a `3`. A causa dell'hoisting, `var` alloca un singolo slot di memoria per la variabile, quindi ogni iterazione sovrascrive la stessa variabile invece di crearne una nuova. -Nel secondo loop, la variabile `i` è stata dichiarata usando la chiave `let`: le variabili dichiarate con la chiave `let` (e `const`) hanno lo scope del blocco (un blocco è qualsiasi cosa tra `{ }`). Durante ogni iterazione, `i` avrà un nuovo valore e ogni valore avrà lo scope all'interno del loop. +Nel secondo loop, la variabile `i` è stata dichiarata usando la chiave `let`: le variabili dichiarate con la chiave `let` (e `const`) hanno lo scope del blocco (un blocco è qualsiasi cosa tra `{ }`). Durante ogni iterazione, `i` avrà un nuovo valore e ogni valore avrà lo scope all'interno del loop. A differenza di `var`, `let` crea un nuovo binding (un nuovo slot di memoria) per ogni iterazione, motivo per cui ogni callback `setTimeout` cattura un valore diverso.

diff --git a/ja-JA/README-ja_JA.md b/ja-JA/README-ja_JA.md index 577982ce..3a8da252 100644 --- a/ja-JA/README-ja_JA.md +++ b/ja-JA/README-ja_JA.md @@ -90,9 +90,9 @@ for (let i = 0; i < 3; i++) { #### 答え: C -JavaScriptのイベントキューのため、`setTimeout`コールバック関数はループが実行された後に呼び出されます。最初のループの変数 `i`は`var`キーワードを使って宣言されているので、この値はグローバル変数となります。ループの間、単項演算子 `++`を使用して、毎回 `i`の値を`1`ずつインクリメントしました。 最初の例では `setTimeout`コールバック関数が呼び出されるまでに`i`は`3`となりました。 +JavaScriptのイベントキューのため、`setTimeout`コールバック関数はループが実行された後に呼び出されます。最初のループの変数 `i`は`var`キーワードを使って宣言されているので、この値はグローバル変数となります。ループの間、単項演算子 `++`を使用して、毎回 `i`の値を`1`ずつインクリメントしました。 最初の例では `setTimeout`コールバック関数が呼び出されるまでに`i`は`3`となりました。ホイスティングにより、`var` は変数に単一のメモリスロットを割り当てるため、各イテレーションは新しい変数を作成するのではなく、同じ変数を上書きします。 -2番目のループでは、変数 `i`が `let`キーワードを使って宣言されました。 `let`（または`const`）キーワードで宣言された変数はブロックスコープです（ブロックは `{}`の間のものです）。それぞれの繰り返しの間、 `i`は新しい値を持ち、それぞれの値はループの内側にあります。 +2番目のループでは、変数 `i`が `let`キーワードを使って宣言されました。 `let`（または`const`）キーワードで宣言された変数はブロックスコープです（ブロックは `{}`の間のものです）。それぞれの繰り返しの間、 `i`は新しい値を持ち、それぞれの値はループの内側にあります。`var` とは異なり、`let` はイテレーションごとに新しいバインディング（新しいメモリスロット）を作成するため、各 `setTimeout` コールバックが異なる値をキャプチャします。

diff --git a/ko-KR/README-ko_KR.md b/ko-KR/README-ko_KR.md index 51411b6b..768529cf 100644 --- a/ko-KR/README-ko_KR.md +++ b/ko-KR/README-ko_KR.md @@ -102,9 +102,9 @@ for (let i = 0; i < 3; i++) { #### 답: C -JavaScript의 이벤트 큐 때문에, `setTimeout`의 콜백 함수는 루프가 실행된 _후에_ 호출돼요. 첫 번째의 루프의 변수 `i`는 `var` 키워드를 사용해 선언되어 전역 값이 돼요. 루프 동안, 단항 연산자 `++`를 사용해 매번 `i`의 값을 `1`씩 증가시켰어요. `setTimeout`콜백 함수가 호출되기까지, 첫 번째 예시에서의 `i`는 `3`이에요. +JavaScript의 이벤트 큐 때문에, `setTimeout`의 콜백 함수는 루프가 실행된 _후에_ 호출돼요. 첫 번째의 루프의 변수 `i`는 `var` 키워드를 사용해 선언되어 전역 값이 돼요. 루프 동안, 단항 연산자 `++`를 사용해 매번 `i`의 값을 `1`씩 증가시켰어요. `setTimeout`콜백 함수가 호출되기까지, 첫 번째 예시에서의 `i`는 `3`이에요. 호이스팅으로 인해 `var`는 변수에 단일 메모리 슬롯을 할당하므로 각 반복이 새 변수를 생성하는 대신 동일한 변수를 덮어씁니다. -두 번째 루프에서, 변수 `i`는 `let` 키워드를 사용해 선언되었어요: `let`(그리고 `const`) 키워드로 선언된 변수는 블록-스코프예요(블록은 `{ }` 사이의 모든 것). 각각을 반복하는 동안, `i`는 새로운 값을 갖게 되고, 각각의 값은 루프 스코프 안에 있어요. +두 번째 루프에서, 변수 `i`는 `let` 키워드를 사용해 선언되었어요: `let`(그리고 `const`) 키워드로 선언된 변수는 블록-스코프예요(블록은 `{ }` 사이의 모든 것). 각각을 반복하는 동안, `i`는 새로운 값을 갖게 되고, 각각의 값은 루프 스코프 안에 있어요. `var`와 달리 `let`은 각 반복마다 새로운 바인딩(새 메모리 슬롯)을 생성하므로 각 `setTimeout` 콜백이 다른 값을 캡처합니다.

diff --git a/nl-NL/README.md b/nl-NL/README.md index ffc14a97..5470ce2e 100644 --- a/nl-NL/README.md +++ b/nl-NL/README.md @@ -98,9 +98,9 @@ for (let i = 0; i < 3; i++) { #### Antwoord: C -Vanwege de Event Queue in JavaScript wordt de `setTimeout` callback functie aangeroepen _nadat_ de volledige loop is uitgevoerd. Omndat in de eerste loop de variabele `i` gedeclareerd wordt met het keyword `var`, wordt deze global gemaakt. Tijdens de loop verhogen we de waarde van `i` met `1` door middel van de unary operator `++`. Tegen de tijd dat de `setTimeout` callback functie wordt aangeroepen is de waarde van `i` al `3`, zoals te zien is in het eerste voorbeeld. +Vanwege de Event Queue in JavaScript wordt de `setTimeout` callback functie aangeroepen _nadat_ de volledige loop is uitgevoerd. Omndat in de eerste loop de variabele `i` gedeclareerd wordt met het keyword `var`, wordt deze global gemaakt. Tijdens de loop verhogen we de waarde van `i` met `1` door middel van de unary operator `++`. Tegen de tijd dat de `setTimeout` callback functie wordt aangeroepen is de waarde van `i` al `3`, zoals te zien is in het eerste voorbeeld. Vanwege hoisting reserveert `var` een enkele geheugenplek voor de variabele, waardoor elke iteratie dezelfde variabele overschrijft in plaats van een nieuwe aan te maken. -In de tweede loop wordt de variabele `i` gedeclareerd met het keyword `let`: variabelen die gedeclareerd worden met het keyword `let` (en `const`) zijn block-scoped (een scope is alles tussen `{ }`). Tijdens elke iteratie zal `i` een nieuwe waarde krijgen, en elke waarde is scoped (te gebruiken tussen `{ }`) in de loop. +In de tweede loop wordt de variabele `i` gedeclareerd met het keyword `let`: variabelen die gedeclareerd worden met het keyword `let` (en `const`) zijn block-scoped (een scope is alles tussen `{ }`). Tijdens elke iteratie zal `i` een nieuwe waarde krijgen, en elke waarde is scoped (te gebruiken tussen `{ }`) in de loop. In tegenstelling tot `var` creëert `let` bij elke iteratie een nieuwe binding (een nieuwe geheugenplek), waardoor elke `setTimeout`-callback een andere waarde vastlegt.

diff --git a/pl-PL/README.md b/pl-PL/README.md index ef1c71d6..2959d61e 100644 --- a/pl-PL/README.md +++ b/pl-PL/README.md @@ -105,9 +105,9 @@ for (let i = 0; i < 3; i++) { #### Odpowiedź: C -Ze względu na kolejkę zdarzeń w JavaScript, funkcja zwrotna `setTimeout` jest wywoływana _po_ wykonaniu pętli. Ponieważ zmienna `i` w pierwszej pętli została zadeklarowana za pomocą słowa kluczowego `var`, jej wartość była globalna. Podczas pętli inkrementowaliśmy wartość `i` o `1` za każdym razem, używając operatora jednoargumentowego `++`. W momencie wywołania funkcji zwrotnej `setTimeout`, `i` miało wartość `3` w pierwszym przykładzie. +Ze względu na kolejkę zdarzeń w JavaScript, funkcja zwrotna `setTimeout` jest wywoływana _po_ wykonaniu pętli. Ponieważ zmienna `i` w pierwszej pętli została zadeklarowana za pomocą słowa kluczowego `var`, jej wartość była globalna. Podczas pętli inkrementowaliśmy wartość `i` o `1` za każdym razem, używając operatora jednoargumentowego `++`. W momencie wywołania funkcji zwrotnej `setTimeout`, `i` miało wartość `3` w pierwszym przykładzie. Z powodu hoistingu, `var` przydziela pojedynczy slot pamięci dla zmiennej, więc każda iteracja nadpisuje tę samą zmienną, zamiast tworzyć nową. -W drugiej pętli zmienna `i` została zadeklarowana za pomocą słowa kluczowego `let`: zmienne zadeklarowane za pomocą słowa kluczowego `let` (i `const`) mają zakres blokowy (blokiem jest cokolwiek między `{ }`). Podczas każdej iteracji `i` będzie miało nową wartość, a każda wartość będzie miała zakres wewnątrz pętli. +W drugiej pętli zmienna `i` została zadeklarowana za pomocą słowa kluczowego `let`: zmienne zadeklarowane za pomocą słowa kluczowego `let` (i `const`) mają zakres blokowy (blokiem jest cokolwiek między `{ }`). Podczas każdej iteracji `i` będzie miało nową wartość, a każda wartość będzie miała zakres wewnątrz pętli. W przeciwieństwie do `var`, `let` tworzy nowe wiązanie (nowy slot pamięci) dla każdej iteracji, dlatego każdy callback `setTimeout` przechwytuje inną wartość.

diff --git a/pt-BR/README_pt_BR.md b/pt-BR/README_pt_BR.md index 54c8daf1..e3da6053 100644 --- a/pt-BR/README_pt_BR.md +++ b/pt-BR/README_pt_BR.md @@ -85,9 +85,9 @@ for (let i = 0; i < 3; i++) { #### Resposta: C -Por causa da fila de eventos em JavaScript, a callback de `setTimeout` é chamada depois do laço ter sido executado. Já que a variável `i` no primeiro laço foi declarada usando a palavra-chave `var`, seu valor era global. Durante o laço, incrementamos o valor de `i` por `1` em cada repetição, usando o operador unário `++`. Quando a callback de `setTimeout` foi chamada, `i` valia `3`. +Por causa da fila de eventos em JavaScript, a callback de `setTimeout` é chamada depois do laço ter sido executado. Já que a variável `i` no primeiro laço foi declarada usando a palavra-chave `var`, seu valor era global. Durante o laço, incrementamos o valor de `i` por `1` em cada repetição, usando o operador unário `++`. Quando a callback de `setTimeout` foi chamada, `i` valia `3`. Devido ao hoisting, `var` aloca um único slot de memória para a variável, então cada iteração sobrescreve a mesma variável em vez de criar uma nova. -No segundo laço, a variável `i` foi declarada usando a palavra-chave `let`: Variáveis declaradas com `let` (e `const`) só são acessíveis nos escopos de seus blocos (um bloco é qualquer código entre `{ }`). Durante cada repetição do laço, `i` vai ter um novo valor, e cada valor tem seu escopo dentro do laço. +No segundo laço, a variável `i` foi declarada usando a palavra-chave `let`: Variáveis declaradas com `let` (e `const`) só são acessíveis nos escopos de seus blocos (um bloco é qualquer código entre `{ }`). Durante cada repetição do laço, `i` vai ter um novo valor, e cada valor tem seu escopo dentro do laço. Ao contrário de `var`, `let` cria uma nova ligação (um novo slot de memória) para cada iteração, e é por isso que cada callback `setTimeout` captura um valor diferente.

diff --git a/ro-RO/README.ro.md b/ro-RO/README.ro.md index 93fc1f4e..2783e043 100644 --- a/ro-RO/README.ro.md +++ b/ro-RO/README.ro.md @@ -101,9 +101,9 @@ for (let i = 0; i < 3; i++) { #### Răspuns: C -Datorită cozii de evenimente din JavaScript, funcția de callback `setTimeout` este apelată _după_ ce bucla a fost executată. Deoarece variabila `i` din prima buclă a fost declarată folosind cuvântul cheie `var`, această valoare a fost globală. În timpul buclei, am incrementat valoarea lui `i` cu `1` de fiecare dată, folosind operatorul unary `++`. Până când funcția de callback `setTimeout` a fost invocată, `i` era egal cu `3` în primul exemplu. +Datorită cozii de evenimente din JavaScript, funcția de callback `setTimeout` este apelată _după_ ce bucla a fost executată. Deoarece variabila `i` din prima buclă a fost declarată folosind cuvântul cheie `var`, această valoare a fost globală. În timpul buclei, am incrementat valoarea lui `i` cu `1` de fiecare dată, folosind operatorul unary `++`. Până când funcția de callback `setTimeout` a fost invocată, `i` era egal cu `3` în primul exemplu. Din cauza hoisting-ului, `var` alocă un singur slot de memorie pentru variabilă, astfel încât fiecare iterație suprascrie aceeași variabilă în loc să creeze una nouă. -În cea de-a doua buclă, variabila `i` a fost declarată folosind cuvântul cheie `let`: variabilele declarate cu cuvântul cheie `let` (și `const`) sunt cu scop la nivel de bloc (un bloc este orice între `{ }`). În fiecare iterație, `i` va avea o valoare nouă, iar fiecare valoare este în cadrul buclei. +În cea de-a doua buclă, variabila `i` a fost declarată folosind cuvântul cheie `let`: variabilele declarate cu cuvântul cheie `let` (și `const`) sunt cu scop la nivel de bloc (un bloc este orice între `{ }`). În fiecare iterație, `i` va avea o valoare nouă, iar fiecare valoare este în cadrul buclei. Spre deosebire de `var`, `let` creează o nouă legătură (un nou slot de memorie) pentru fiecare iterație, motiv pentru care fiecare callback `setTimeout` capturează o valoare diferită.

diff --git a/ru-RU/README.md b/ru-RU/README.md index ace3f67a..4226b69e 100644 --- a/ru-RU/README.md +++ b/ru-RU/README.md @@ -101,9 +101,9 @@ for (let i = 0; i < 3; i++) { #### Ответ: C -Из-за очереди событий в JavaScript, функция `setTimeout` вызывается _после_ того как цикл будет завершен. Так как переменная `i` в первом цикле была определена с помощью `var`, она будет глобальной. В цикле мы каждый раз увеличиваем значение `i` на `1`, используя унарный оператор `++`. К моменту выполнения функции `setTimeout` значение `i` будет равно `3` в первом примере. +Из-за очереди событий в JavaScript, функция `setTimeout` вызывается _после_ того как цикл будет завершен. Так как переменная `i` в первом цикле была определена с помощью `var`, она будет глобальной. В цикле мы каждый раз увеличиваем значение `i` на `1`, используя унарный оператор `++`. К моменту выполнения функции `setTimeout` значение `i` будет равно `3` в первом примере. Из-за всплытия (hoisting) `var` выделяет **одну ячейку памяти** для переменной, поэтому каждая итерация перезаписывает одну и ту же переменную, а не создаёт новую. -Во втором цикле переменная `i` определена с помощью `let`. Такие переменные (а также `const`) имеют блочную область видимости (блок это что угодно между `{ }`). С каждой итерацией `i` будет иметь новое значение, и каждое значение будет замкнуто в своей области видимости внутри цикла. +Во втором цикле переменная `i` определена с помощью `let`. Такие переменные (а также `const`) имеют блочную область видимости (блок это что угодно между `{ }`). С каждой итерацией `i` будет иметь новое значение, и каждое значение будет замкнуто в своей области видимости внутри цикла. В отличие от `var`, `let` создаёт новую привязку (новую ячейку памяти) на каждой итерации, поэтому каждый колбэк `setTimeout` захватывает своё уникальное значение.

diff --git a/sq-KS/README_sq_KS.md b/sq-KS/README_sq_KS.md index 2392abb4..69348ec2 100644 --- a/sq-KS/README_sq_KS.md +++ b/sq-KS/README_sq_KS.md @@ -100,9 +100,9 @@ for (let i = 0; i < 3; i++) { #### Përgjigja: C -Për shkak të ***event queque*** në JavaScript, funksioni callback `setTimeout` thirret pas ekzekutimit të unazës. Pasi që variabla `i` në iterimin e parë u deklarua duke përdorur fjalën kyçe `var`, kjo vlerë ishte globale. Gjatë unazës, ne rritëm vlerën e `i` me `1` çdo herë, duke përdorur operatorin unar `++`. Deri në kohën që funksioni callback `setTimeout` u thirr, `i` ishte e barabartë me `3` në unazën e parë. +Për shkak të ***event queque*** në JavaScript, funksioni callback `setTimeout` thirret pas ekzekutimit të unazës. Pasi që variabla `i` në iterimin e parë u deklarua duke përdorur fjalën kyçe `var`, kjo vlerë ishte globale. Gjatë unazës, ne rritëm vlerën e `i` me `1` çdo herë, duke përdorur operatorin unar `++`. Deri në kohën që funksioni callback `setTimeout` u thirr, `i` ishte e barabartë me `3` në unazën e parë. Për shkak të hoisting-ut, `var` ndan një vend të vetëm në memorie për variablin, kështu që çdo përsëritje mbishkruan të njëjtin variabël në vend që të krijojë një të ri. -Në unazën e dytë, variabla `i` u deklarua duke përdorur fjalën kyçe `let`: variablat e deklaruara me fjalën kyçe `let` (dhe `const`) janë të qasshme në bllok (një bllok është çdo gjë mes `{ }`). Gjatë çdo iteracioni, `i` do të ketë një vlerë të re, dhe çdo vlerë është e qasshme brenda unazës. +Në unazën e dytë, variabla `i` u deklarua duke përdorur fjalën kyçe `let`: variablat e deklaruara me fjalën kyçe `let` (dhe `const`) janë të qasshme në bllok (një bllok është çdo gjë mes `{ }`). Gjatë çdo iteracioni, `i` do të ketë një vlerë të re, dhe çdo vlerë është e qasshme brenda unazës. Ndryshe nga `var`, `let` krijon një lidhje të re (një vend të ri në memorie) për çdo përsëritje, prandaj çdo callback i `setTimeout` kap një vlerë të ndryshme.

diff --git a/th-TH/README.md b/th-TH/README.md index a5948da5..db660595 100644 --- a/th-TH/README.md +++ b/th-TH/README.md @@ -97,9 +97,9 @@ for (let i = 0; i < 3; i++) { #### คำตอบ: C -เพราะว่าลำดับเหตุการที่เกิดขึ้นใน Javascript ฟังก์ชัน `setTimeout` ที่เป็น callback ถูกเรียก _หลังจาก_ loop รันเสร็จ เนื่องจากตัวแปร `i` ใน loop แรกถูกประกาศด้วยคีย์เวิร์ด `var` จึงทำให้มันเป็น global scope ระหว่างการวนรอบ loop เป็นการเพิ่มค่า `i` ที่ละ `1` ในแต่ละครั้งด้วย unary operator `++`. ในเวลาที่ `setTimeout` callback ถูกเรียก แต่ว่าค่า `i` มีค่าเท่ากับ `3` แล้วดังตัวอย่างแรก +เพราะว่าลำดับเหตุการที่เกิดขึ้นใน Javascript ฟังก์ชัน `setTimeout` ที่เป็น callback ถูกเรียก _หลังจาก_ loop รันเสร็จ เนื่องจากตัวแปร `i` ใน loop แรกถูกประกาศด้วยคีย์เวิร์ด `var` จึงทำให้มันเป็น global scope ระหว่างการวนรอบ loop เป็นการเพิ่มค่า `i` ที่ละ `1` ในแต่ละครั้งด้วย unary operator `++`. ในเวลาที่ `setTimeout` callback ถูกเรียก แต่ว่าค่า `i` มีค่าเท่ากับ `3` แล้วดังตัวอย่างแรก เนื่องจากการ hoisting, `var` จัดสรรหน่วยความจำเพียงช่องเดียวสำหรับตัวแปร ดังนั้นแต่ละรอบการวนซ้ำจะเขียนทับตัวแปรเดียวกันแทนที่จะสร้างตัวแปรใหม่ -ใน loop ที่สอง ตัวแปร `i` ถูกประกาศโดยใช้คีย์เวิร์ด `let` : ตัวแปรที่ประกาศด้วยคีย์เวิร์ด `let` (และ `const`) เป็น block-scope (block คืออะไรก็ตามที่อยู่ภายใน `{ }`) ค่า `i` แต่ละค่าจะถูกกำหนดขอบเขตภายใน loop ในเวลาที่ `setTimeout` callback ถูกเรียก ค่า `i` แต่ละค่าจะเป็นค่าเฉพาะของแต่ละ callback `1 2 และ 3` ตามละดับ +ใน loop ที่สอง ตัวแปร `i` ถูกประกาศโดยใช้คีย์เวิร์ด `let` : ตัวแปรที่ประกาศด้วยคีย์เวิร์ด `let` (และ `const`) เป็น block-scope (block คืออะไรก็ตามที่อยู่ภายใน `{ }`) ค่า `i` แต่ละค่าจะถูกกำหนดขอบเขตภายใน loop ในเวลาที่ `setTimeout` callback ถูกเรียก ค่า `i` แต่ละค่าจะเป็นค่าเฉพาะของแต่ละ callback `1 2 และ 3` ตามละดับ แตกต่างจาก `var` ตรงที่ `let` สร้าง binding ใหม่ (ช่องหน่วยความจำใหม่) ในแต่ละรอบการวนซ้ำ ซึ่งเป็นสาเหตุที่ callback ของ `setTimeout` แต่ละตัวเก็บค่าที่แตกต่างกัน

diff --git a/tr-TR/README-tr_TR.md b/tr-TR/README-tr_TR.md index f1b36c1f..d8dc80cf 100644 --- a/tr-TR/README-tr_TR.md +++ b/tr-TR/README-tr_TR.md @@ -89,9 +89,9 @@ for (let i = 0; i < 3; i++) { #### Cevap: C -Javascript'deki olay kuyruğundan dolayı, `setTimeout` callback fonksiyonu, döngü uygulandıktan _sonra_ çağrılır. `i` değişkeni, ilk döngü sırasında `var` anahtar kelimesi ile tanımlandığından, bu değişken globaldir. Döngü boyunca, `++` unary operatörünü kullanarak, `i`'nin değerini her seferinde `1` arttırdık. İlk örnekte, `setTimeout` callback fonksiyonu çağrıldığı zaman, `i`'nin değeri `3`'e eşitti. +Javascript'deki olay kuyruğundan dolayı, `setTimeout` callback fonksiyonu, döngü uygulandıktan _sonra_ çağrılır. `i` değişkeni, ilk döngü sırasında `var` anahtar kelimesi ile tanımlandığından, bu değişken globaldir. Döngü boyunca, `++` unary operatörünü kullanarak, `i`'nin değerini her seferinde `1` arttırdık. İlk örnekte, `setTimeout` callback fonksiyonu çağrıldığı zaman, `i`'nin değeri `3`'e eşitti. Hoisting nedeniyle, `var` değişken için tek bir bellek alanı ayırır, bu nedenle her yineleme yeni bir değişken oluşturmak yerine aynı değişkenin üzerine yazar. -İkinci döngüde, `i` değişkeni `let` anahtar kelimesi kullanılarak tanımlandı: `let` (ve `const`) ile tanımlanan değişkenler "block-scope"dur (block `{}` arasındaki herhangi bir şeydir). Her bir tekrarda, `i` yeni değere sahip olacak ve her değer döngü içinde "scoped" olacak. +İkinci döngüde, `i` değişkeni `let` anahtar kelimesi kullanılarak tanımlandı: `let` (ve `const`) ile tanımlanan değişkenler "block-scope"dur (block `{}` arasındaki herhangi bir şeydir). Her bir tekrarda, `i` yeni değere sahip olacak ve her değer döngü içinde "scoped" olacak. `var`'ın aksine, `let` her yineleme için yeni bir bağlama (yeni bir bellek alanı) oluşturur, bu nedenle her `setTimeout` callback'i farklı bir değer yakalar.

diff --git a/uk-UA/README.md b/uk-UA/README.md index 6498cc94..fda66a00 100644 --- a/uk-UA/README.md +++ b/uk-UA/README.md @@ -84,9 +84,9 @@ for (let i = 0; i < 3; i++) { #### Відповідь: C -Через черги подій в JavaScript, функція `setTimeout` викликається _після того_ як цикл буде завершено. Так як змінна `i` в першому циклі була визначена за допомогою `var`, вона буде глобальною. У циклі ми кожен раз збільшуємо значення `i` на `1`, використовуючи унарний оператор `++.` До моменту виконання функції `setTimeout` значення `i` дорівнюватиме `3`, як показано в першому прикладі. +Через черги подій в JavaScript, функція `setTimeout` викликається _після того_ як цикл буде завершено. Так як змінна `i` в першому циклі була визначена за допомогою `var`, вона буде глобальною. У циклі ми кожен раз збільшуємо значення `i` на `1`, використовуючи унарний оператор `++.` До моменту виконання функції `setTimeout` значення `i` дорівнюватиме `3`, як показано в першому прикладі. Через hoisting, `var` виділяє єдину комірку пам'яті для змінної, тому кожна ітерація перезаписує ту саму змінну, а не створює нову. -У другому циклі змінна `i` визначена за допомогою `let`. Такі змінні (а також `const`) мають блокову область видимості (блок це що завгодно між `{}`). З кожною ітерацією `i` матиме нове значення, і кожне значення буде замкнуто у своїй області видимості всередині циклу. +У другому циклі змінна `i` визначена за допомогою `let`. Такі змінні (а також `const`) мають блокову область видимості (блок це що завгодно між `{}`). З кожною ітерацією `i` матиме нове значення, і кожне значення буде замкнуто у своїй області видимості всередині циклу. На відміну від `var`, `let` створює нове зв'язування (нову комірку пам'яті) для кожної ітерації, тому кожен колбек `setTimeout` захоплює різне значення.

diff --git a/vi-VI/README-vi.md b/vi-VI/README-vi.md index f8ab661d..00cc235f 100644 --- a/vi-VI/README-vi.md +++ b/vi-VI/README-vi.md @@ -85,9 +85,9 @@ for (let i = 0; i < 3; i++) { #### Đáp án: C -Bởi vì event queue trong JavaScript, hàm `setTimeout` callback sẽ được gọi _sau khi_ vòng lặp được thực hiện. Bời vì biến `i` trong vòng lặp đầu tiên được khai báo với từ khóa `var`, nên nó sẽ là một biến global. Trong suốt vòng lặp, mỗi lần chúng ta tăng giá trị của `i` lên `1`, sử dụng phép toán `++`. Cho tới khi callback `setTimeout` được gọi, giá trị của `i` đã trở thành `3` rồi. +Bởi vì event queue trong JavaScript, hàm `setTimeout` callback sẽ được gọi _sau khi_ vòng lặp được thực hiện. Bời vì biến `i` trong vòng lặp đầu tiên được khai báo với từ khóa `var`, nên nó sẽ là một biến global. Trong suốt vòng lặp, mỗi lần chúng ta tăng giá trị của `i` lên `1`, sử dụng phép toán `++`. Cho tới khi callback `setTimeout` được gọi, giá trị của `i` đã trở thành `3` rồi. Do hoisting, `var` cấp phát một ô nhớ duy nhất cho biến, vì vậy mỗi lần lặp ghi đè lên cùng một biến thay vì tạo ra một biến mới. -Trong vòng lặp thứ 2, biến `i` được khai báo với từ khóa `let`, có nghĩa nó là một biến block-scoped (block là những gì được viết bên trong cặp ngoặc `{ }`). Tại mỗi vòng lặp, `i` sẽ là một biến mới có một giá trị mới, và giá trị đó có scope là bên trong vòng lặp mà thôi. +Trong vòng lặp thứ 2, biến `i` được khai báo với từ khóa `let`, có nghĩa nó là một biến block-scoped (block là những gì được viết bên trong cặp ngoặc `{ }`). Tại mỗi vòng lặp, `i` sẽ là một biến mới có một giá trị mới, và giá trị đó có scope là bên trong vòng lặp mà thôi. Không giống như `var`, `let` tạo một ràng buộc mới (một ô nhớ mới) cho mỗi lần lặp, đó là lý do tại sao mỗi callback `setTimeout` lại capture một giá trị khác nhau.

diff --git a/zh-CN/README-zh_CN.md b/zh-CN/README-zh_CN.md index 52ca1ee0..b9cd3a35 100644 --- a/zh-CN/README-zh_CN.md +++ b/zh-CN/README-zh_CN.md @@ -62,9 +62,9 @@ for (let i = 0; i < 3; i++) { #### 答案：C -由于 JavaScript 的事件循环，`setTimeout` 回调会在*遍历结束后*才执行。因为在第一个遍历中遍历 `i` 是通过 `var` 关键字声明的，所以这个值是全局作用域下的。在遍历过程中，我们通过一元操作符 `++` 来每次递增 `i` 的值。当 `setTimeout` 回调执行的时候，`i` 的值等于 3。 +由于 JavaScript 的事件循环，`setTimeout` 回调会在*遍历结束后*才执行。因为在第一个遍历中遍历 `i` 是通过 `var` 关键字声明的，所以这个值是全局作用域下的。在遍历过程中，我们通过一元操作符 `++` 来每次递增 `i` 的值。当 `setTimeout` 回调执行的时候，`i` 的值等于 3。由于变量提升（hoisting），`var` 只为变量分配一个内存单元，因此每次迭代都会覆盖同一个变量，而不是创建一个新的变量。 -在第二个遍历中，遍历 `i` 是通过 `let` 关键字声明的：通过 `let` 和 `const` 关键字声明的变量是拥有块级作用域（指的是任何在 {} 中的内容）。在每次的遍历过程中，`i` 都有一个新值，并且每个值都在循环内的作用域中。 +在第二个遍历中，遍历 `i` 是通过 `let` 关键字声明的：通过 `let` 和 `const` 关键字声明的变量是拥有块级作用域（指的是任何在 {} 中的内容）。在每次的遍历过程中，`i` 都有一个新值，并且每个值都在循环内的作用域中。与 `var` 不同，`let` 在每次迭代中都会创建一个新的绑定（新的内存单元），这就是为什么每个 `setTimeout` 回调捕获的值都不同。

diff --git a/zh-TW/README_zh-TW.md b/zh-TW/README_zh-TW.md index b6bf9c06..fe6b0477 100644 --- a/zh-TW/README_zh-TW.md +++ b/zh-TW/README_zh-TW.md @@ -75,9 +75,9 @@ for (let i = 0; i < 3; i++) { #### 答案：C 由於 JavaScript 的事件佇列（Event Queue），`setTimeout` 的 `callback` 會在*遍歷結束後*才執行。因為在第一個迴圈中，遍歷 `i` 是透過 `var` 關鍵字宣告的，`var` 屬於 Function scope（需要用 `function() {}` 才能將值鎖在作用域裡面） -，所以 `for` 迴圈會造成變數外流，變成全域變數。在遍歷過程中，我們透過一元運算子 `++` 來遞增 `i` 的值。當 `setTimeout` 的 `callback` 執行的時候，`i` 的值等於 3。 +，所以 `for` 迴圈會造成變數外流，變成全域變數。在遍歷過程中，我們透過一元運算子 `++` 來遞增 `i` 的值。當 `setTimeout` 的 `callback` 執行的時候，`i` 的值等於 3。由於變數提升（hoisting），`var` 只為變數分配一個記憶體單元，因此每次迭代都會覆蓋同一個變數，而不是建立一個新的變數。 -在第二個迴圈中，遍歷 `i` 是透過 `let` 關鍵字宣告的：透過 `let` 和 `const` 關鍵字的變數擁有塊級作用域（指的是任何在 `{}` 中的内容）。在每次的遍歷過程中，`i` 都有一個新值，每次遍歷時 `i` 值的作用域都在迴圈内。 +在第二個迴圈中，遍歷 `i` 是透過 `let` 關鍵字宣告的：透過 `let` 和 `const` 關鍵字的變數擁有塊級作用域（指的是任何在 `{}` 中的内容）。在每次的遍歷過程中，`i` 都有一個新值，每次遍歷時 `i` 值的作用域都在迴圈内。與 `var` 不同，`let` 在每次迭代中都會建立一個新的繫結（新的記憶體單元），這就是為什麼每個 `setTimeout` 回呼捕獲的值都不同。