Variable scope, closure

1-js/06-advanced-functions/03-closure/1-closure-latest-changes/solution.md

@@ -1,5 +1,5 @@
-The answer is: **Pete**.
+Відповідь: **Петро**.
 
-A function gets outer variables as they are now, it uses the most recent values.
+Функція отримує зовнішні змінні такими, якими вони є зараз, тобто вона використовує останні значення.
 
-Old variable values are not saved anywhere. When a function wants a variable, it takes the current value from its own Lexical Environment or the outer one.
+Старі значення змінних ніде не зберігаються. Коли функція потребує змінної, вона бере поточне значення зі свого власногоабо зовнішнього лексичного середовища.

1-js/06-advanced-functions/03-closure/1-closure-latest-changes/task.md

@@ -1,23 +1,23 @@
-importance: 5
+Важливість: 5
 
 ---
 
-# Does a function pickup latest changes?
+# Чи побачить функція останні зміни?
 
-The function sayHi uses an external variable name. When the function runs, which value is it going to use?
+Функція `sayHi` використовує зовнішню змінну. Яке значення буде використано під час виконання функції?
 
 ```js
-let name = "John";
+let name = "Іван";
 
 function sayHi() {
-  alert("Hi, " + name);
+  alert("Привіт, " + name);
 }
 
-name = "Pete";
+name = "Петро";
 
-sayHi(); // what will it show: "John" or "Pete"?
+sayHi(); // що вона покаже "Іван" чи "Петро"?
 ```
 
-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.
+Такі ситуації поширені як у браузері, так і в серверній розробці. Функцію можна запланувати на виконання пізніше, ніж вона створена, наприклад, після дії користувача або запиту мережі.
 
-So, the question is: does it pick up the latest changes?
+Отже, виникає питання: чи побачить функція останні зміни?

1-js/06-advanced-functions/03-closure/10-make-army/_js.view/solution.js

@@ -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() { // функція shooter
+      alert( i ); // має показати свій номер
     };
     shooters.push(shooter);
   }

1-js/06-advanced-functions/03-closure/10-make-army/_js.view/source.js

@@ -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() { // функція shooter
+      alert( i ); // має показати свій номер
     };
     shooters.push(shooter);
     i++;
@@ -16,7 +16,7 @@ function makeArmy() {
 /*
 let army = makeArmy();
 
-army[0](); // the shooter number 0 shows 10
-army[5](); // and number 5 also outputs 10...
-// ... all shooters show 10 instead of their 0, 1, 2, 3...
+army[0](); // 10 від стрільця за номером 0
+army[5](); // та номер 5 також показує 10...
+// ... всі функції показують 10 замість своїх номерів 0, 1, 2, 3...
 */

1-js/06-advanced-functions/03-closure/10-make-army/_js.view/test.js

@@ -7,13 +7,13 @@ describe("army", function() {
     window.alert = sinon.stub(window, "alert");
   });
 
-  it("army[0] shows 0", function() {
+  it("army[0] показує 0", function() {
     army[0]();
     assert(alert.calledWith(0));
   });
 
 
-  it("army[5] shows 5", function() {
+  it("army[5] показує 5", function() {
     army[5]();
     assert(alert.calledWith(5));
   });

1-js/06-advanced-functions/03-closure/10-make-army/solution.md

@@ -1,14 +1,14 @@
 
-Let's examine what exactly happens inside `makeArmy`, and the solution will become obvious.
+Давайте розберемося, що саме відбувається всередині функції `makeArmy`, і рішення стане очевидним.
 
-1. It creates an empty array `shooters`:
+1. Функція створює порожній масив `shooters`:
 
     ```js
     let shooters = [];
     ```
-2. Fills it with functions via `shooters.push(function)` in the loop.
+2. Наповнює його функціями у циклі через `shooters.push(function)`.
 
-    Every element is a function, so the resulting array looks like this:
+    Кожен елемент є функцією, тому отриманий масив виглядає так:
 
     ```js no-beautify
     shooters = [
@@ -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. Функція повертає масив.
 
-    Then, later, the call to any member, e.g. `army[5]()` will get the element `army[5]` from the array (which is a function) and calls it.
+    Потім, пізніше, виклик будь-якого елемента масиву, напр. `army[5]()` отримає елемент `army[5]` з масиву (який є функцією) і викликає її.
 
-    Now why do all such functions show the same value, `10`?
+    Чому всі функції показують однакове значення, `10`?
 
-    That's because there's no local variable `i` inside `shooter` functions. When such a function is called, it takes `i` from its outer lexical environment.
+    Зверніть увагу, що локальної змінної `i` немає всередині `shooter` функцій. Коли така функція викликається, вона приймає `i` зі свого зовнішнього лексичного середовища.
 
-    Then, what will be the value of `i`?
+    Тоді яке буде значення `i`?
 
-    If we look at the source:
+    Якщо ми подивимося на код:
 
     ```js
     function makeArmy() {
       ...
       let i = 0;
       while (i < 10) {
-        let shooter = function() { // shooter function
-          alert( i ); // should show its number
+        let shooter = function() { // функція shooter
+          alert( i ); // має показати свій номер
         };
-        shooters.push(shooter); // add function to the array
+        shooters.push(shooter); // додати функцію до масиву
         i++;
       }
       ...
     }
     ```
 
-    We can see that all `shooter` functions are created in the lexical environment of `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`).
+    Ми бачимо що усі `shooter` функції створені в лексичному середовищі виклику функції `makeArmy()`. Але коли ми викликаємо `army[5]()`, `makeArmy` вже закінчила свою роботу, і остаточне значення `i` це `10` (цикл `while` зупиняється на `i=10`).
 
-    As the result, all `shooter` functions get the same value from the outer lexical environment and that is, the last value, `i=10`.
+    В результаті всі функції `shooter` отримують однакове значення із зовнішнього лексичного середовища, тобто останнє значення, `i=10`.
 
     ![](lexenv-makearmy-empty.svg)
 
-    As you can see above, on each iteration of a `while {...}` block, a new lexical environment is created. So, to fix this, we can copy the value of `i` into a variable within the `while {...}` block, like this:
+    Як ви можете бачити вище, на кожній ітерації циклу `while {...}`, створюється нове лексичне середовище. Отже, щоб виправити це, ми можемо скопіювати значення `i` у змінну всередині блоку `while {...}`, ось так:
 
     ```js run
     function makeArmy() {
@@ -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() { // функція shooter
+            alert( *!*j*/!* ); // має показати свій номер
           };
         shooters.push(shooter);
         i++;
@@ -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
+    // Тепер код працює правильно
     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.
+    Тут `let j = i` оголошує локальну змінну ітерації `j` та копіює до неї значення зі змінної `i`. Примітиви копіюються "за значенням", тому ми фактично отримуємо незалежну копію `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:
+    Функції тепер працюють правильно, тому що змінна `i` "живе" трохи ближче. Не в лексичному середовищі виклику `makeArmy()`, але в лексичному середовищі, яке відповідає поточній ітерації циклу:
 
     ![](lexenv-makearmy-while-fixed.svg)
 
-    Such a problem could also be avoided if we used `for` in the beginning, like this:
+    Такої проблеми також можна було б уникнути, якби ми використали цикл `for` з самого початку, ось так:
 
     ```js run demo
     function makeArmy() {
@@ -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() { // функція shooter
+          alert( i ); // має показати свій номер
         };
         shooters.push(shooter);
       }
@@ -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 new lexical environment, with its own variable `i`. So `shooter` generated in every iteration references its own `i`, from that very iteration.
+    Це, по суті, те саме, тому що `for` на кожній ітерації створює нове лексичне середовище зі своєю змінною `i`. Тому `shooter` згенерований на кожній ітерації бере посилання на змінну `i`, з тієї самої ітерації.
 
     ![](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?
+Тепер, коли ви доклали так багато зусиль, щоб прочитати це, остаточний рецепт такий простий -- використовуйте цикл `for`, ви можете задатися питанням -- чи було воно того варте?
 
-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. 
+Ну, якби ви могли легко відповісти на запитання, ви б не читали рішення. Тож, сподіваюся, це завдання допомогло вам трохи краще зрозуміти як все працює.
 
-Besides, there are indeed cases when one prefers `while` to `for`, and other scenarios, where such problems are real.
+Крім того, на практиці бувають випадки, коли віддають перевагу `while` замість `for`, та інші сценарії, де такі проблеми є реальними.
 

1-js/06-advanced-functions/03-closure/10-make-army/task.md

@@ -1,41 +1,41 @@
-importance: 5
+Важливість: 5
 
 ---
 
-# Army of functions
+# Армія функцій
 
-The following code creates an array of `shooters`.
+Наступний код створює масив `shooters`.
 
-Every function is meant to output its number. But something is wrong...
+Кожна функція має вивести свій номер. Але щось не так...
 
 ```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() { // створюємо функцію стрільця,
+      alert( i ); // що має показувати свій номер
     };
-    shooters.push(shooter); // and add it to the array
+    shooters.push(shooter); // додаємо її до масиву
     i++;
   }
 
-  // ...and return the array of shooters
+  // ...і повертаємо масив стрільців
   return shooters;
 }
 
 let army = makeArmy();
 
 *!*
-// all shooters show 10 instead of their numbers 0, 1, 2, 3...
-army[0](); // 10 from the shooter number 0
-army[1](); // 10 from the shooter number 1
-army[2](); // 10 ...and so on.
+// всі стрільці показують 10 замість своїх номерів 0, 1, 2, 3...
+army[0](); // 10 від стрільця за номером 0
+army[1](); // 10 від стрільця за номером 1
+army[2](); // 10 ...і так далі.
 */!*
 ```
 
-Why do all of the shooters show the same value? 
+Чому всі функції показують однакове значення?
 
-Fix the code so that they work as intended.
+Виправте код так, щоб він працював як передбачалося.
 

1-js/06-advanced-functions/03-closure/2-closure-variable-access/solution.md

@@ -1,9 +1,9 @@
-The answer is: **Pete**.
+Відповідь: **Pete**.
 
-The `work()` function in the code below gets `name` from the place of its origin through the outer lexical environment reference:
+Функція `work()` в коді нижче отримує `name` від місця його походження через посилання на зовнішнє лексичне середовище:
 
 ![](lexenv-nested-work.svg)
 
-So, the result is `"Pete"` here.
+Отже, відповіддю буде `"Pete"`.
 
-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"`.
+Але якби не було `let name` у `makeWorker()`, тоді пошук вийшов би за межі лексичного середовища та взяв би глобальну змінну, як ми бачимо з ланцюжка вище. В такому випадку відповідь була б `"John"`.

1-js/06-advanced-functions/03-closure/2-closure-variable-access/task.md

@@ -1,12 +1,12 @@
-importance: 5
+Важливість: 5
 
 ---
 
-# Which variables are available?
+# Які змінні доступні?
 
-The function `makeWorker` below makes another function and returns it. That new function can be called from somewhere else.
+Функція `makeWorker` нижче створює іншу функцію і повертає її. Цю нову функцію можна викликати звідкись ще.
 
-Will it have access to the outer variables from its creation place, or the invocation place, or both?
+Чи матиме вона доступ до зовнішніх змінних з місця створення, з місця виклику, чи з обох?
 
 ```js
 function makeWorker() {
@@ -19,11 +19,11 @@ function makeWorker() {
 
 let name = "John";
 
-// create a function
+// створити функцію
 let work = makeWorker();
 
-// call it
-work(); // what will it show?
+// викликати її
+work(); // Що вона покаже?
 ```
 
-Which value it will show? "Pete" or "John"?
+Яке значення вона покаже? "Pete" чи "John"?

1-js/06-advanced-functions/03-closure/3-counter-independent/solution.md

@@ -1,5 +1,5 @@
 The answer: **0,1.**
 
-Functions `counter` and `counter2` are created by different invocations of `makeCounter`.
+Функції `counter` і `counter2` створюються різними викликами `makeCounter`.
 
-So they have independent outer Lexical Environments, each one has its own `count`.
+Отже, вони мають незалежні зовнішні лексичні середовища, кожне з яких має свою власну змінну `count`.

1-js/06-advanced-functions/03-closure/3-counter-independent/task.md

@@ -1,12 +1,12 @@
-importance: 5
+Важливість: 5
 
 ---
 
-# Are counters independent?
+# Чи лічильники незалежні?
 
-Here we make two counters: `counter` and `counter2` using the same `makeCounter` function.
+Тут ми створюємо два лічильника: `counter` та `counter2` використовуючи однакову функцію `makeCounter`.
 
-Are they independent? What is the second counter going to show? `0,1` or `2,3` or something else?
+Вони незалежні? Що покаже другий лічильник? `0,1` чи `2,3` чи щось інше?
 
 ```js
 function makeCounter() {

1-js/06-advanced-functions/03-closure/4-counter-object-independent/solution.md

@@ -1,7 +1,7 @@
 
-Surely it will work just fine.
+Безумовно, він буде чудово працювати.
 
-Both nested functions are created within the same outer Lexical Environment, so they share access to the same `count` variable:
+Обидві вкладені функції створюються в межах єдиного зовнішнього лексичного середовища, тому вони мають спільний доступ до однієї змінної `count`:
 
 ```js run
 function Counter() {

1-js/06-advanced-functions/03-closure/4-counter-object-independent/task.md

@@ -1,12 +1,12 @@
-importance: 5
+Важливість: 5
 
 ---
 
-# Counter object
+# Об’єкт лічильника
 
-Here a counter object is made with the help of the constructor function.
+Тут лічильник створюється за допомогою функції конструктора.
 
-Will it work? What will it show?
+Чи буде він працювати? Що він покаже?
 
 ```js
 function Counter() {

1-js/06-advanced-functions/03-closure/5-function-in-if/solution.md

@@ -1,3 +1,3 @@
-The result is **an error**.
+Результатом буде **помилка**.
 
-The function `sayHi` is declared inside the `if`, so it only lives inside it. There is no `sayHi` outside.
+Функція `sayHi` оголошується всередині `if`, тому вона доступна тільки всередині нього. Зовні функції `sayHi` не існує.