Mar 11, 2023 · Mar 11, 2023 · Mar 11, 2023 · Mar 15, 2023 · Mar 15, 2023 · Mar 15, 2023
diff --git a/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/solution.md b/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/solution.md
 The answer is: **Pete**.
 Đáp án là: **Pete**.

 A function gets outer variables as they are now, it uses the most recent values.
 Một hàm nhận các biến bên ngoài như hiện tại, nó sử dụng các giá trị gần đây nhất.

 Old variable values are not saved anywhere. When a function wants a variable, it takes the current value from its own Lexical Environmentor the outer one.
 Giá trị biến cũ không được lưu ở bất cứ đâu. Khi một hàm muốn một biến, nó sẽ lấy giá trị hiện tại từ Lexical Environmentcủa chính nó hoặc environment bên ngoài.
diff --git a/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/task.md b/1-js/06-advanced-functions/03-closure/1-closure-latest-changes/task.md

 ---

 #Does a function pickup latest changes?
 #Hàm có nhận thay đổi mới nhất không?

 The functionsayHiuses an external variable name. When the function runs, which value is it going to use?
 HàmsayHisử dụng tên biến ngoài. Khi hàm chạy, nó sẽ sử dụng giá trị nào?

 ```js
 let name = "John";

 name = "Pete";

 sayHi(); //what will it show: "John"or "Pete"?
 sayHi(); //nó sẽ hiển thị gì: "John"hay "Pete"?
 ```

 Such situations are common both in browser and server-side development. A function may be scheduled to execute later than it is created, for instance after a user action or a network request.
 Những tình huống như vậy là phổ biến cả trong phát triển trình duyệt và phía máy chủ. Một hàm có thể được lên lịch để thực thi muộn hơn so với khi nó được tạo, chẳng hạn như sau một hành động của người dùng hoặc một yêu cầu mạng.

 So, the question is: does it pick up the latest changes?
 Vì vậy, câu hỏi là: nó có nhận những thay đổi mới nhất không?
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/solution.js b/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/solution.js
  let shooters = [];

  for(let i = 0; i < 10; i++) {
    let shooter = function() { //shooter function
      alert( i ); //should show its number
    let shooter = function() { //hàm shooter
      alert( i ); //nên hiện số của nó
    };
    shooters.push(shooter);
  }
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/source.js b/1-js/06-advanced-functions/03-closure/10-make-army/_js.view/source.js

  let i = 0;
  while (i < 10) {
    let shooter = function() { //shooter function
      alert( i ); //should show its number
    let shooter = function() { //hàm shooter
      alert( i ); //nên hiện số của nó
    };
    shooters.push(shooter);
    i++;
 /*
 let army = makeArmy();

 army[0](); //theshooternumber 0shows 10
 army[5](); //and number 5also outputs 10...
 // ...all shooters show10instead of their 0, 1, 2, 3...
 army[0](); // shootersố 0hiển thị 10
 army[5](); //và số 5cũng ra 10...
 // ...tất cả các shooter hiển thị10thay vì số của chúng 0, 1, 2, 3...
 */
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/lexenv-makearmy-empty.svg b/1-js/06-advanced-functions/03-closure/10-make-army/lexenv-makearmy-empty.svg
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/lexenv-makearmy-for-fixed.svg b/1-js/06-advanced-functions/03-closure/10-make-army/lexenv-makearmy-for-fixed.svg
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/lexenv-makearmy-while-fixed.svg b/1-js/06-advanced-functions/03-closure/10-make-army/lexenv-makearmy-while-fixed.svg
diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/solution.md b/1-js/06-advanced-functions/03-closure/10-make-army/solution.md

 Let's examine what exactly happens inside`makeArmy`, and the solution will become obvious.
 Hãy xem xét chính xác điều gì xảy ra bên trong`makeArmy` và giải pháp sẽ trở nên rõ ràng.

 1.It creates an empty array `shooters`:
 1.Nó tạo ra một array `shooters` trống:

    ```js
    let shooters = [];
    ```
 2.Fills it with functions via`shooters.push(function)`in the loop.
 2.Điền vào nó các hàm thông qua`shooters.push(function)`trong vòng lặp.

 Every element is a function, so the resultingarraylooks like this:
 Mỗi phần tử là một hàm, vì vậyarraykết quả trông như thế này:

    ```js no-beautify
    shooters = [
    ];
    ```

 3.The array is returned from the function.
 3.Array được trả về từ hàm.

 Then, later, the call to any member, e.g. `army[5]()`will get the element `army[5]`from thearray (which is a function) and calls it.
 Sau đó, sau đó, cuộc gọi đến bất kỳ thành viên nào, ví dụ:. `army[5]()`sẽ lấy phần tử `army[5]`từarray (là một hàm) và gọi nó.

 Now why do all such functions show the same value, `10`?
 Bây giờ tại sao tất cả các chức năng như vậy hiển thị cùng một giá trị, `10`?

 That's because there's no local variable`i`inside`shooter` functions. When such a function is called, it takes`i`from its outerlexical environment.
 Đó là bởi vì không có biến cục bộ`i`bên trong các hàm`shooter`. Khi một hàm như vậy được gọi, nó sẽ lấy`i`từlexical environment bên ngoài của nó.

 Then, what will be the value of`i`?
 Khi đó, giá trị của`i` sẽ là bao nhiêu?

 If we look at the source:
 Nếu chúng ta nhìn vào nguồn:

    ```js
    function makeArmy() {
      ...
      let i = 0;
      while (i < 10) {
        let shooter = function() { //shooter function
          alert( i ); //should show its number
        let shooter = function() { //hàm shooter
          alert( i ); //nên hiển thị số của nó
        };
        shooters.push(shooter); //add function to the array
        shooters.push(shooter); //thêm hàm vào array
        i++;
      }
      ...
    }
    ```

 We can see that all`shooter`functions are created in thelexical environmentof`makeArmy()` function. But when `army[5]()`is called, `makeArmy`has already finished its job, and the final value of`i`is `10` (`while`stops at `i=10`).
 Chúng ta có thể thấy rằng tất cả các hàm`shooter`đều được tạo tronglexical environmentcủa hàm`makeArmy()`. Nhưng khi `army[5]()`được gọi, `makeArmy`đã hoàn thành công việc của nó và giá trị cuối cùng của`i`là `10` (`while`dừng ở `i=10`).

 As the result, all`shooter`functions get the same value from the outerlexical environmentand that is, the last value, `i=10`.
 Kết quả là, tất cả các hàm`shooter`nhận cùng một giá trị từlexical environmentbên ngoài và đó là giá trị cuối cùng, `i=10`.

    ![](lexenv-makearmy-empty.svg)

 As you can see above, on each iteration of a`while {...}` block, a newlexical environmentis created. So, to fix this, we can copy the value of`i`into a variable within the `while {...}` block, like this:
 Như bạn có thể thấy ở trên, trên mỗi lần lặp của khối`while {...}`, mộtlexical environmentmới được tạo. Vì vậy, để khắc phục điều này, chúng ta có thể sao chép giá trị của`i`vào một biến trong khối `while {...}`, như sau:

    ```js run
    function makeArmy() {
        *!*
          let j = i;
        */!*
          let shooter = function() { //shooter function
            alert( *!*j*/!* ); //should show its number
          let shooter = function() { //hàm shooter
            alert( *!*j*/!* ); //nên hiển thị số của nó
          };
        shooters.push(shooter);
        i++;

    let army = makeArmy();

    //Now the code works correctly
    //Bây giờ mã hoạt động đúng
    army[0](); // 0
    army[5](); // 5
    ```

 Here`let j = i`declares an "iteration-local" variable`j`and copies`i`into it. Primitives are copied "by value",so we actually get an independent copy of`i`,belonging to the current loop iteration.
 Ở đây`let j = i`khai báo một biến "lặp cục bộ"`j`và sao chép`i`vào đó. Các bản gốc được sao chép "theo giá trị",vì vậy chúng ta thực sự nhận được một bản sao độc lập của`i`,thuộc về phép lặp vòng lặp hiện tại.

    The shooters work correctly, because the value of `i` now lives a little bit closer. Not in `makeArmy()` Lexical Environment, but in the Lexical Environment that corresponds to the current loop iteration:

    ![](lexenv-makearmy-while-fixed.svg)

 Such a problem could also be avoided if we used`for`in the beginning, like this:
 Vấn đề như vậy cũng có thể tránh được nếu chúng ta sử dụng`for`ngay từ đầu, như sau:

    ```js run demo
    function makeArmy() {
    *!*
      for(let i = 0; i < 10; i++) {
    */!*
        let shooter = function() { //shooter function
          alert( i ); //should show its number
        let shooter = function() { //hàm shooter
          alert( i ); //nên hiển thị số của nó
        };
        shooters.push(shooter);
      }
    army[5](); // 5
    ```

 That's essentially the same, because`for`on each iteration generates a newlexical environment, with its own variable`i`.So`shooter`generated in every iteration references its own`i`, from that very iteration.
 Điều đó về cơ bản là giống nhau, bởi vì`for`trên mỗi lần lặp tạo ra mộtlexical environment mới, với biến riêng`i`.Vì vậy,`shooter`được tạo trong mỗi lần lặp tham chiếu`i` của chính nó, từ chính lần lặp đó.

    ![](lexenv-makearmy-for-fixed.svg)

 Now, as you've put so much effort into reading this, and the final recipe is so simple - just use`for`,you may wonder--was it worth that?
 Bây giờ, vì bạn đã bỏ ra rất nhiều công sức để đọc nó, và công thức cuối cùng rất đơn giản - chỉ cần sử dụng`for`,bạn có thể tự hỏi--nó có đáng không?

 Well, if you could easily answer the question, you wouldn't read the solution. So, hopefully this task must have helped you to understand things a bit better.
 Chà, nếu bạn có thể dễ dàng trả lời câu hỏi, bạn sẽ không đọc lời giải. Vì vậy, hy vọng nhiệm vụ này đã giúp bạn hiểu mọi thứ tốt hơn một chút.

 Besides, there are indeed cases when one prefers`while`to`for`,and other scenarios, where such problems are real.
 Bên cạnh đó, thực sự có những trường hợp khi một người thích`while`hơn là`for`,và các tình huống khác, trong đó các vấn đề như vậy là có thật.

diff --git a/1-js/06-advanced-functions/03-closure/10-make-army/task.md b/1-js/06-advanced-functions/03-closure/10-make-army/task.md

 ---

 #Army of functions
 #Đội quân hàm

 The following code creates anarrayof `shooters`.
 Đoạn mã sau tạo ra mộtarraycủa `shooters`.

 Every function is meant to output its number. But something is wrong...
 Mọi chức năng đều xuất ra số của nó. Nhưng có gì đó không ổn...

 ```js run
 function makeArmy() {
  let shooters = [];

  let i = 0;
  while (i < 10) {
    let shooter = function() { //create a shooter function,
      alert( i ); //that should show its number
    let shooter = function() { //tạo một hàm shooter,
      alert( i ); //điều đó nên hiển thị số của nó
    };
    shooters.push(shooter); //and add it to the array
    shooters.push(shooter); //và thêm nó vào array
    i++;
  }

  // ...and return the arrayof shooters
  // ....và trả lại arrayshooter
  return shooters;
 }

 let army = makeArmy();

 *!*
 //all shooters show10instead of their numbers 0, 1, 2, 3...
 army[0](); // 10from theshooternumber 0
 army[1](); // 10from theshooternumber 1
 army[2](); // 10 ...and so on.
 //tất cả các shooter hiển thị10thay vì số của chúng 0, 1, 2, 3...
 army[0](); // 10từshootersố 0
 army[1](); // 10từshootersố 1
 army[2](); // 10 ... vân vân.
 */!*
 ```

 Why do all of the shooters show the same value?
 Tại sao tất cả các shooter hiển thị cùng một giá trị?

 Fix the code so that they work as intended.
 Sửa mã để chúng hoạt động như dự định.

diff --git a/...-advanced-functions/03-closure/2-closure-variable-access/lexenv-nested-work.svg b/...-advanced-functions/03-closure/2-closure-variable-access/lexenv-nested-work.svg
diff --git a/1-js/06-advanced-functions/03-closure/2-closure-variable-access/solution.md b/1-js/06-advanced-functions/03-closure/2-closure-variable-access/solution.md
 The answer is: **Pete**.
 Đáp án là: **Pete**.

 The `work()`function in the code below gets `name`from the place of its origin through the outerlexical environmentreference:
 Hàm `work()`trong đoạn mã bên dưới lấy `name`từ nơi xuất phát của nó thông qua tham chiếulexical environmentbên ngoài:

 ![](lexenv-nested-work.svg)

 So, the result is `"Pete"`here.
 Vì vậy, kết quả là `"Pete"`ở đây.

 But if there were no`let name`in `makeWorker()`,then the search would go outside and take the global variable as we can see from the chain above. In that case the result would be `"John"`.
 Nhưng nếu không có`let name`trong `makeWorker()`,thì tìm kiếm sẽ ra bên ngoài và lấy biến cục bộ như chúng ta có thể thấy từ chuỗi bên trên. Trong trường hợp đó, kết quả sẽ là `"John"`.
diff --git a/1-js/06-advanced-functions/03-closure/2-closure-variable-access/task.md b/1-js/06-advanced-functions/03-closure/2-closure-variable-access/task.md

 ---

 #Which variables are available?
 #Những biến nào có sẵn?

 The function`makeWorker`below makes another function and returns it. That new function can be called from somewhere else.
 Hàm`makeWorker`bên dưới tạo một hàm khác và trả về hàm đó. Hàm mới đó có thể được gọi từ một nơi khác.

 Will it have access to the outer variables from its creation place, or the invocation place, or both?
 Nó sẽ có quyền truy cập vào các biến bên ngoài từ nơi tạo của nó, hay nơi gọi, hay cả hai?

 ```js
 function makeWorker() {

 let name = "John";

 //create a function
 //tạo một hàm
 let work = makeWorker();

 //call it
 work(); //what will it show?
 //gọi nó
 work(); //nó sẽ hiển thị những gì?
 ```

 Which value it will show? "Pete"or "John"?
 Nó sẽ hiển thị giá trị nào? "Pete"hay "John"?
diff --git a/1-js/06-advanced-functions/03-closure/3-counter-independent/solution.md b/1-js/06-advanced-functions/03-closure/3-counter-independent/solution.md
 The answer: **0,1.**
 Đáp án: **0,1.**

 Functions`counter`and `counter2`are created by different invocations of `makeCounter`.
 Các hàm`counter`và `counter2`được tạo bởi các lệnh gọi khác nhau của `makeCounter`.

 So they have independent outer LexicalEnvironments, each one has its own`count`.
 Vì vậy, chúng có các LexicalEnvironment bên ngoài độc lập, mỗi environment có`count` riêng.
diff --git a/1-js/06-advanced-functions/03-closure/3-counter-independent/task.md b/1-js/06-advanced-functions/03-closure/3-counter-independent/task.md

 ---

 #Are counters independent?
 #Bộ đếm có độc lập không?

 Here we make two counters: `counter`and `counter2`using the same`makeCounter` function.
 Ở đây chúng ta tạo hai bộ đếm: `counter`và `counter2`bằng cách sử dụng cùng hàm`makeCounter`.

 Are they independent? What is the second counter going to show? `0,1`or `2,3`or something else?
 Chúng có độc lập không? Bộ đếm thứ hai sẽ hiển thị là gì? `0,1`hay `2,3`hay cái gì khác?

 ```js
 function makeCounter() {
diff --git a/1-js/06-advanced-functions/03-closure/4-counter-object-independent/solution.md b/1-js/06-advanced-functions/03-closure/4-counter-object-independent/solution.md

 Surely it will work just fine.
 Chắc chắn nó sẽ hoạt động tốt.

 Both nested functions are created within the same outerLexical Environment, so they share access to the same`count` variable:
 Cả hai hàm lồng nhau đều được tạo trong cùng mộtLexical Environment bên ngoài, vì vậy chúng chia sẻ quyền truy cập vào cùng một biến`count`:

 ```js run
 function Counter() {
diff --git a/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md b/1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md

 ---

 #Counter object
 #Đối tượng bộ đếm

 Here a counter object is made with the help of the constructor function.
 Ở đây, một đối tượng bộ đếm được tạo với sự trợ giúp của hàm tạo.

 Will it work? What will it show?
 Nó có hoạt động không? Nó sẽ hiển thị cái gì?

 ```js
 function Counter() {
diff --git a/1-js/06-advanced-functions/03-closure/5-function-in-if/solution.md b/1-js/06-advanced-functions/03-closure/5-function-in-if/solution.md
 The result is **an error**.
 Kết quả là **một lỗi**.

 The function`sayHi`is declared inside the`if`,so it only lives inside it. There is no`sayHi`outside.
 Hàm`sayHi`được khai báo bên trong`if`,vì vậy nó chỉ tồn tại bên trong nó. Không có`sayHi`bên ngoài.
diff --git a/1-js/06-advanced-functions/03-closure/5-function-in-if/task.md b/1-js/06-advanced-functions/03-closure/5-function-in-if/task.md

 #Function in if
 #Hàm trong if

 Look at the code. What will be the result of the call at the last line?
 Nhìn vào mã. Cái gì sẽ là kết quả của cuộc gọi ở dòng cuối cùng?

 ```js run
 let phrase = "Hello";
diff --git a/1-js/06-advanced-functions/03-closure/6-closure-sum/solution.md b/1-js/06-advanced-functions/03-closure/6-closure-sum/solution.md
 For the second parentheses to work, the first ones must return a function.
 Để các dấu ngoặc đơn thứ hai hoạt động, các dấu ngoặc đơn đầu tiên phải trả về một hàm.

 Like this:
 Như thế này:

 ```js run
 function sum(a) {

  return function(b) {
    return a + b; //takes "a"from the outerlexical environment
    return a + b; //lấy "a"từlexical environment bên ngoài
  };

 }
diff --git a/1-js/06-advanced-functions/03-closure/6-closure-sum/task.md b/1-js/06-advanced-functions/03-closure/6-closure-sum/task.md

 ---

 #Sum with closures
 #Tổng có bao đóng

 Write function `sum`that works like this: `sum(a)(b) = a+b`.
 Viết hàm `sum`hoạt động như sau: `sum(a)(b) = a+b`.

 Yes, exactly this way, using double parentheses (not a mistype).
 Vâng, chính xác theo cách này, sử dụng dấu ngoặc kép (không phải gõ nhầm).

 For instance:
 Ví dụ:

 ```js
 sum(1)(2) = 3
Original file line number	Diff line number	Diff line change
		@@ -1,5 +1,5 @@
		The answer is: Pete.
		Đáp án là: Pete.

		A function gets outer variables as they are now, it uses the most recent values.
		Một hàm nhận các biến bên ngoài như hiện tại, nó sử dụng các giá trị gần đây nhất.

		Old variable values are not saved anywhere. When a function wants a variable, it takes the current value from its own Lexical Environmentor the outer one.
		Giá trị biến cũ không được lưu ở bất cứ đâu. Khi một hàm muốn một biến, nó sẽ lấy giá trị hiện tại từ Lexical Environmentcủa chính nó hoặc environment bên ngoài.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,9 +2,9 @@ importance: 5

		---

		#Does a function pickup latest changes?
		#Hàm có nhận thay đổi mới nhất không?

		The functionsayHiuses an external variable name. When the function runs, which value is it going to use?
		HàmsayHisử dụng tên biến ngoài. Khi hàm chạy, nó sẽ sử dụng giá trị nào?

		```js
		let name = "John";
Expand All		@@ -15,9 +15,9 @@ function sayHi() {

		name = "Pete";

		sayHi(); //what will it show: "John"or "Pete"?
		sayHi(); //nó sẽ hiển thị gì: "John"hay "Pete"?
		```

		Such situations are common both in browser and server-side development. A function may be scheduled to execute later than it is created, for instance after a user action or a network request.
		Những tình huống như vậy là phổ biến cả trong phát triển trình duyệt và phía máy chủ. Một hàm có thể được lên lịch để thực thi muộn hơn so với khi nó được tạo, chẳng hạn như sau một hành động của người dùng hoặc một yêu cầu mạng.

		So, the question is: does it pick up the latest changes?
		Vì vậy, câu hỏi là: nó có nhận những thay đổi mới nhất không?
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,8 +3,8 @@ function makeArmy() {
		let shooters = [];

		for(let i = 0; i < 10; i++) {
		let shooter = function() { //shooter function
		alert( i ); //should show its number
		let shooter = function() { //hàm shooter
		alert( i ); //nên hiện số của nó
		};
		shooters.push(shooter);
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,8 +3,8 @@ function makeArmy() {

		let i = 0;
		while (i < 10) {
		let shooter = function() { //shooter function
		alert( i ); //should show its number
		let shooter = function() { //hàm shooter
		alert( i ); //nên hiện số của nó
		};
		shooters.push(shooter);
		i++;
Expand All		@@ -16,7 +16,7 @@ function makeArmy() {
		/*
		let army = makeArmy();

		army[0](); //theshooternumber 0shows 10
		army[5](); //and number 5also outputs 10...
		// ...all shooters show10instead of their 0, 1, 2, 3...
		army[0](); // shootersố 0hiển thị 10
		army[5](); //và số 5cũng ra 10...
		// ...tất cả các shooter hiển thị10thay vì số của chúng 0, 1, 2, 3...
		*/
Original file line number	Diff line number	Diff line change
		@@ -1,14 +1,14 @@

		Let's examine what exactly happens inside`makeArmy`, and the solution will become obvious.
		Hãy xem xét chính xác điều gì xảy ra bên trong`makeArmy` và giải pháp sẽ trở nên rõ ràng.

		1.It creates an empty array `shooters`:
		1.Nó tạo ra một array `shooters` trống:

		```js
		let shooters = [];
		```
		2.Fills it with functions via`shooters.push(function)`in the loop.
		2.Điền vào nó các hàm thông qua`shooters.push(function)`trong vòng lặp.

		Every element is a function, so the resultingarraylooks like this:
		Mỗi phần tử là một hàm, vì vậyarraykết quả trông như thế này:

		```js no-beautify
		shooters = [
Expand All		@@ -25,40 +25,40 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
		];
		```

		3.The array is returned from the function.
		3.Array được trả về từ hàm.

		Then, later, the call to any member, e.g. `army[5]()`will get the element `army[5]`from thearray (which is a function) and calls it.
		Sau đó, sau đó, cuộc gọi đến bất kỳ thành viên nào, ví dụ:. `army[5]()`sẽ lấy phần tử `army[5]`từarray (là một hàm) và gọi nó.

		Now why do all such functions show the same value, `10`?
		Bây giờ tại sao tất cả các chức năng như vậy hiển thị cùng một giá trị, `10`?

		That's because there's no local variable`i`inside`shooter` functions. When such a function is called, it takes`i`from its outerlexical environment.
		Đó là bởi vì không có biến cục bộ`i`bên trong các hàm`shooter`. Khi một hàm như vậy được gọi, nó sẽ lấy`i`từlexical environment bên ngoài của nó.

		Then, what will be the value of`i`?
		Khi đó, giá trị của`i` sẽ là bao nhiêu?

		If we look at the source:
		Nếu chúng ta nhìn vào nguồn:

		```js
		function makeArmy() {
		...
		let i = 0;
		while (i < 10) {
		let shooter = function() { //shooter function
		alert( i ); //should show its number
		let shooter = function() { //hàm shooter
		alert( i ); //nên hiển thị số của nó
		};
		shooters.push(shooter); //add function to the array
		shooters.push(shooter); //thêm hàm vào array
		i++;
		}
		...
		}
		```

		We can see that all`shooter`functions are created in thelexical environmentof`makeArmy()` function. But when `army[5]()`is called, `makeArmy`has already finished its job, and the final value of`i`is `10` (`while`stops at `i=10`).
		Chúng ta có thể thấy rằng tất cả các hàm`shooter`đều được tạo tronglexical environmentcủa hàm`makeArmy()`. Nhưng khi `army[5]()`được gọi, `makeArmy`đã hoàn thành công việc của nó và giá trị cuối cùng của`i`là `10` (`while`dừng ở `i=10`).

		As the result, all`shooter`functions get the same value from the outerlexical environmentand that is, the last value, `i=10`.
		Kết quả là, tất cả các hàm`shooter`nhận cùng một giá trị từlexical environmentbên ngoài và đó là giá trị cuối cùng, `i=10`.

		![](lexenv-makearmy-empty.svg)

		As you can see above, on each iteration of a`while {...}` block, a newlexical environmentis created. So, to fix this, we can copy the value of`i`into a variable within the `while {...}` block, like this:
		Như bạn có thể thấy ở trên, trên mỗi lần lặp của khối`while {...}`, mộtlexical environmentmới được tạo. Vì vậy, để khắc phục điều này, chúng ta có thể sao chép giá trị của`i`vào một biến trong khối `while {...}`, như sau:

		```js run
		function makeArmy() {
Expand All		@@ -69,8 +69,8 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
		!
		let j = i;
		/!
		let shooter = function() { //shooter function
		alert( !j/! ); //should show its number
		let shooter = function() { //hàm shooter
		alert( !j/! ); //nên hiển thị số của nó
		};
		shooters.push(shooter);
		i++;
Expand All		@@ -81,18 +81,18 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco

		let army = makeArmy();

		//Now the code works correctly
		//Bây giờ mã hoạt động đúng
		army[0](); // 0
		army[5](); // 5
		```

		Here`let j = i`declares an "iteration-local" variable`j`and copies`i`into it. Primitives are copied "by value",so we actually get an independent copy of`i`,belonging to the current loop iteration.
		Ở đây`let j = i`khai báo một biến "lặp cục bộ"`j`và sao chép`i`vào đó. Các bản gốc được sao chép "theo giá trị",vì vậy chúng ta thực sự nhận được một bản sao độc lập của`i`,thuộc về phép lặp vòng lặp hiện tại.

		The shooters work correctly, because the value of `i` now lives a little bit closer. Not in `makeArmy()` Lexical Environment, but in the Lexical Environment that corresponds to the current loop iteration:

		![](lexenv-makearmy-while-fixed.svg)

		Such a problem could also be avoided if we used`for`in the beginning, like this:
		Vấn đề như vậy cũng có thể tránh được nếu chúng ta sử dụng`for`ngay từ đầu, như sau:

		```js run demo
		function makeArmy() {
Expand All		@@ -102,8 +102,8 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
		!
		for(let i = 0; i < 10; i++) {
		/!
		let shooter = function() { //shooter function
		alert( i ); //should show its number
		let shooter = function() { //hàm shooter
		alert( i ); //nên hiển thị số của nó
		};
		shooters.push(shooter);
		}
Expand All		@@ -117,13 +117,13 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
		army[5](); // 5
		```

		That's essentially the same, because`for`on each iteration generates a newlexical environment, with its own variable`i`.So`shooter`generated in every iteration references its own`i`, from that very iteration.
		Điều đó về cơ bản là giống nhau, bởi vì`for`trên mỗi lần lặp tạo ra mộtlexical environment mới, với biến riêng`i`.Vì vậy,`shooter`được tạo trong mỗi lần lặp tham chiếu`i` của chính nó, từ chính lần lặp đó.

		![](lexenv-makearmy-for-fixed.svg)

		Now, as you've put so much effort into reading this, and the final recipe is so simple - just use`for`,you may wonder--was it worth that?
		Bây giờ, vì bạn đã bỏ ra rất nhiều công sức để đọc nó, và công thức cuối cùng rất đơn giản - chỉ cần sử dụng`for`,bạn có thể tự hỏi--nó có đáng không?

		Well, if you could easily answer the question, you wouldn't read the solution. So, hopefully this task must have helped you to understand things a bit better.
		Chà, nếu bạn có thể dễ dàng trả lời câu hỏi, bạn sẽ không đọc lời giải. Vì vậy, hy vọng nhiệm vụ này đã giúp bạn hiểu mọi thứ tốt hơn một chút.

		Besides, there are indeed cases when one prefers`while`to`for`,and other scenarios, where such problems are real.
		Bên cạnh đó, thực sự có những trường hợp khi một người thích`while`hơn là`for`,và các tình huống khác, trong đó các vấn đề như vậy là có thật.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,40 +2,40 @@ importance: 5

		---

		#Army of functions
		#Đội quân hàm

		The following code creates anarrayof `shooters`.
		Đoạn mã sau tạo ra mộtarraycủa `shooters`.

		Every function is meant to output its number. But something is wrong...
		Mọi chức năng đều xuất ra số của nó. Nhưng có gì đó không ổn...

		```js run
		function makeArmy() {
		let shooters = [];

		let i = 0;
		while (i < 10) {
		let shooter = function() { //create a shooter function,
		alert( i ); //that should show its number
		let shooter = function() { //tạo một hàm shooter,
		alert( i ); //điều đó nên hiển thị số của nó
		};
		shooters.push(shooter); //and add it to the array
		shooters.push(shooter); //và thêm nó vào array
		i++;
		}

		// ...and return the arrayof shooters
		// ....và trả lại arrayshooter
		return shooters;
		}

		let army = makeArmy();

		!
		//all shooters show10instead of their numbers 0, 1, 2, 3...
		army[0](); // 10from theshooternumber 0
		army[1](); // 10from theshooternumber 1
		army[2](); // 10 ...and so on.
		//tất cả các shooter hiển thị10thay vì số của chúng 0, 1, 2, 3...
		army[0](); // 10từshootersố 0
		army[1](); // 10từshootersố 1
		army[2](); // 10 ... vân vân.
		/!
		```

		Why do all of the shooters show the same value?
		Tại sao tất cả các shooter hiển thị cùng một giá trị?

		Fix the code so that they work as intended.
		Sửa mã để chúng hoạt động như dự định.
Original file line number	Diff line number	Diff line change
		@@ -1,9 +1,9 @@
		The answer is: Pete.
		Đáp án là: Pete.

		The `work()`function in the code below gets `name`from the place of its origin through the outerlexical environmentreference:
		Hàm `work()`trong đoạn mã bên dưới lấy `name`từ nơi xuất phát của nó thông qua tham chiếulexical environmentbên ngoài:

		![](lexenv-nested-work.svg)

		So, the result is `"Pete"`here.
		Vì vậy, kết quả là `"Pete"`ở đây.

		But if there were no`let name`in `makeWorker()`,then the search would go outside and take the global variable as we can see from the chain above. In that case the result would be `"John"`.
		Nhưng nếu không có`let name`trong `makeWorker()`,thì tìm kiếm sẽ ra bên ngoài và lấy biến cục bộ như chúng ta có thể thấy từ chuỗi bên trên. Trong trường hợp đó, kết quả sẽ là `"John"`.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,11 +2,11 @@ importance: 5

		---

		#Which variables are available?
		#Những biến nào có sẵn?

		The function`makeWorker`below makes another function and returns it. That new function can be called from somewhere else.
		Hàm`makeWorker`bên dưới tạo một hàm khác và trả về hàm đó. Hàm mới đó có thể được gọi từ một nơi khác.

		Will it have access to the outer variables from its creation place, or the invocation place, or both?
		Nó sẽ có quyền truy cập vào các biến bên ngoài từ nơi tạo của nó, hay nơi gọi, hay cả hai?

		```js
		function makeWorker() {
Expand All		@@ -19,11 +19,11 @@ function makeWorker() {

		let name = "John";

		//create a function
		//tạo một hàm
		let work = makeWorker();

		//call it
		work(); //what will it show?
		//gọi nó
		work(); //nó sẽ hiển thị những gì?
		```

		Which value it will show? "Pete"or "John"?
		Nó sẽ hiển thị giá trị nào? "Pete"hay "John"?
Original file line number	Diff line number	Diff line change
		@@ -1,5 +1,5 @@
		The answer: 0,1.
		Đáp án: 0,1.

		Functions`counter`and `counter2`are created by different invocations of `makeCounter`.
		Các hàm`counter`và `counter2`được tạo bởi các lệnh gọi khác nhau của `makeCounter`.

		So they have independent outer LexicalEnvironments, each one has its own`count`.
		Vì vậy, chúng có các LexicalEnvironment bên ngoài độc lập, mỗi environment có`count` riêng.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,11 +2,11 @@ importance: 5

		---

		#Are counters independent?
		#Bộ đếm có độc lập không?

		Here we make two counters: `counter`and `counter2`using the same`makeCounter` function.
		Ở đây chúng ta tạo hai bộ đếm: `counter`và `counter2`bằng cách sử dụng cùng hàm`makeCounter`.

		Are they independent? What is the second counter going to show? `0,1`or `2,3`or something else?
		Chúng có độc lập không? Bộ đếm thứ hai sẽ hiển thị là gì? `0,1`hay `2,3`hay cái gì khác?

		```js
		function makeCounter() {
Expand Down