не відбудиться.
+
+Ось наводиться приклад інструкції switch`:
+
+```js
+switch(lowercaseLetter) {
+ case "a":
+ console.log("A");
+ break;
+ case "b":
+ console.log("B");
+ break;
+}
+```
+
+`case` значень перевіряється абсолютною рівністю (`===`). `break` пропонує JavaScript припинити виконання інструкцій. Якщо `break` пропущений, тоді наступна команда буде виконуватись.
+
+# --instructions--
+
+Напишіть команду switch, щоб встановити `answer` за наступних умов:
+`1` - `alpha`
+`2` - `beta`
+`3` - `gamma`
+`4` - `delta`
+
+# --hints--
+
+`caseInSwitch(1)` повинно відповідати значенню рядка `alpha`
+
+```js
+assert(caseInSwitch(1) === 'alpha');
+```
+
+`caseInSwitch(2)` повинно відповідати значенню рядка `beta`
+
+```js
+assert(caseInSwitch(2) === 'beta');
+```
+
+`caseInSwitch(3)` повинно відповідати значенню рядка `gamma`
+
+```js
+assert(caseInSwitch(3) === 'gamma');
+```
+
+`caseInSwitch(4)` повинно відповідати значенню рядка `delta`
+
+```js
+assert(caseInSwitch(4) === 'delta');
+```
+
+Не варто використовувати `if` або `else` команди
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+Ви повинні мати принаймні 3 інструкції `break`
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function caseInSwitch(val) {
+ let answer = "";
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+ return answer;
+}
+
+caseInSwitch(1);
+```
+
+# --solutions--
+
+```js
+function caseInSwitch(val) {
+ let answer = "";
+
+ switch(val) {
+ case 1:
+ answer = "alpha";
+ break;
+ case 2:
+ answer = "beta";
+ break;
+ case 3:
+ answer = "gamma";
+ break;
+ case 4:
+ answer = "delta";
+ }
+ return answer;
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
new file mode 100644
index 00000000000..b6002732b79
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md
@@ -0,0 +1,97 @@
+---
+id: 56533eb9ac21ba0edf2244bc
+title: Список покупок
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9MEKHZ'
+forumTopicId: 18280
+dashedName: shopping-list
+---
+
+# --description--
+
+Створіть список покупок у змінній `myList`. Список повинен бути багатовимірним масивом, який містить декілька підмасивів.
+
+Перший елемент у кожному підмасиві повинен містити рядок з назвою одиниці. Другий елемент повинен бути числом, яке відображає кількість.
+
+```js
+["Chocolate Bar", 15]
+```
+
+У списку повинно бути щонайменше 5 підмасивів.
+
+# --hints--
+
+`myList` повинен бути масивом.
+
+```js
+assert(isArray);
+```
+
+Першими елементами у кожному з ваших підмасивів повинні бути рядки.
+
+```js
+assert(hasString);
+```
+
+Другими елементами у кожному підмасиві повинні бути числа.
+
+```js
+assert(hasNumber);
+```
+
+У списку має бути щонайменше 5 одиниць.
+
+```js
+assert(count > 4);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+var count = 0;
+var isArray = false;
+var hasString = false;
+var hasNumber = false;
+(function(list){
+ if(Array.isArray(myList)) {
+ isArray = true;
+ if(myList.length > 0) {
+ hasString = true;
+ hasNumber = true;
+ for (var elem of myList) {
+ if(!elem || !elem[0] || typeof elem[0] !== 'string') {
+ hasString = false;
+ }
+ if(!elem || typeof elem[1] !== 'number') {
+ hasNumber = false;
+ }
+ }
+ }
+ count = myList.length;
+ return JSON.stringify(myList);
+ } else {
+ return "myList is not an array";
+ }
+
+})(myList);
+```
+
+## --seed-contents--
+
+```js
+const myList = [];
+```
+
+# --solutions--
+
+```js
+const myList = [
+ ["Candy", 10],
+ ["Potatoes", 12],
+ ["Eggs", 12],
+ ["Catfood", 1],
+ ["Toads", 9]
+];
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
new file mode 100644
index 00000000000..902f4f5836f
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md
@@ -0,0 +1,116 @@
+---
+id: 56533eb9ac21ba0edf2244c6
+title: Стояти в черзі
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8Q8tP'
+forumTopicId: 18307
+dashedName: stand-in-line
+---
+
+# --description--
+
+В комп'ютерних науках queue це абстрактне поняття Data Structure, де усі елементи зберігають певний порядок. Нові елементи можуть бути додані до черги, а старі елементи - зняті з черги.
+
+Напишіть функцію `nextInLine`, аргументами якої є масив (`arr`) та число (`item`).
+
+Додайте число до кінця масиву, а тоді видаліть перший елемент з масиву.
+
+Функція `nextInLine` повинна повернути видалений елемент.
+
+# --hints--
+
+`nextInLine([], 5)` має повернути до числа.
+
+```js
+assert.isNumber(nextInLine([], 5));
+```
+
+`nextInLine([], 1)` має повернути до `1`
+
+```js
+assert(nextInLine([], 1) === 1);
+```
+
+`nextInLine([2], 1)` має повернути до `2`
+
+```js
+assert(nextInLine([2], 1) === 2);
+```
+
+`nextInLine([5,6,7,8,9], 1)` має повернути до `5`
+
+```js
+assert(nextInLine([5, 6, 7, 8, 9], 1) === 5);
+```
+
+Після `nextInLine(testArr, 10)`, код `testArr[4]` має стати `10`
+
+```js
+nextInLine(testArr, 10);
+assert(testArr[4] === 10);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = [];
+var originalConsole = console
+function capture() {
+ var nativeLog = console.log;
+ console.log = function (message) {
+ logOutput.push(message);
+ if(nativeLog.apply) {
+ nativeLog.apply(originalConsole, arguments);
+ } else {
+ var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+ nativeLog(nativeMsg);
+ }
+ };
+}
+
+function uncapture() {
+ console.log = originalConsole.log;
+}
+
+capture();
+```
+
+## --after-user-code--
+
+```js
+uncapture();
+testArr = [1,2,3,4,5];
+(function() { return logOutput.join("\n");})();
+```
+
+## --seed-contents--
+
+```js
+function nextInLine(arr, item) {
+ // Only change code below this line
+
+ return item;
+ // Only change code above this line
+}
+
+// Setup
+const testArr = [1, 2, 3, 4, 5];
+
+// Display code
+console.log("Before: " + JSON.stringify(testArr));
+console.log(nextInLine(testArr, 6));
+console.log("After: " + JSON.stringify(testArr));
+```
+
+# --solutions--
+
+```js
+const testArr = [1, 2, 3, 4, 5];
+
+function nextInLine(arr, item) {
+ arr.push(item);
+ return arr.shift();
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
new file mode 100644
index 00000000000..b51fa94707c
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md
@@ -0,0 +1,63 @@
+---
+id: bd7993c9c69feddfaeb8bdef
+title: Зберігання кількох значень в одній змінній, використовуючи масиви JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQWAm'
+forumTopicId: 18309
+dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
+---
+
+# --description--
+
+Зі змінними масивів `array` JavaScript, ми можемо зберігати частини даних в одному місці.
+
+Ви починаєте оголошення масиву з відкритої квадратної дужки, а завершуєте його закриваючи квадратною дужкою і ставлячи кому між кожним елементом приблизно так:
+
+```js
+const sandwich = ["peanut butter", "jelly", "bread"];
+```
+
+# --instructions--
+
+Змініть масив `myArray` так, щоб він містив і рядок, і число (у цьому порядку).
+
+# --hints--
+
+`myArray` повинен бути масивом.
+
+```js
+assert(typeof myArray == 'object');
+```
+
+Першим елементом у масиві `myArray` має бути рядок.
+
+```js
+assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
+```
+
+Другий пункт в `myArray` має бути числом.
+
+```js
+assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myArray = [];
+```
+
+# --solutions--
+
+```js
+const myArray = ["The Answer", 42];
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
new file mode 100644
index 00000000000..fab1d208f88
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md
@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244a8
+title: Зберігання значень за допомогою оператора присвоєння
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEanysE'
+forumTopicId: 18310
+dashedName: storing-values-with-the-assignment-operator
+---
+
+# --description--
+
+In JavaScript ви можете зберігати значення в змінній assignment з оператором (`=`).
+
+```js
+myVariable = 5;
+```
+
+Вона призначає `Number` зі значенням `5` до `myVariable`.
+
+Якщо праворуч від оператора є будь-які розрахунки `=`, ті з них, які розташовані перед значенням належать до змінної зліва від оператора.
+
+```js
+var myVar;
+myVar = 5;
+```
+
+Спочатку, цей код створює змінну з ім'ям `myVar`. Тоді код присвоює `5` на `myVar`. Тепер, якщо `myVar` знову з'являється в коді, програма буде розглядати його так, як `5`.
+
+# --instructions--
+
+Надайте значення `7` змінній `a`.
+
+# --hints--
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(/var a;/.test(code));
+```
+
+`a` має мати значення 7.
+
+```js
+assert(typeof a === 'number' && a === 7);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+ a = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a){return "a = " + a;})(a);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
new file mode 100644
index 00000000000..3668b2d3734
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md
@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb4bdef
+title: Віднімати одне число від іншого використовуючи JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3yQtk'
+forumTopicId: 18314
+dashedName: subtract-one-number-from-another-with-javascript
+---
+
+# --description--
+
+Ми також можемо віднімати одне число від іншого.
+
+JavaScript використовує символ `-` для віднімання.
+
+**Наприклад**
+
+```js
+const myVar = 12 - 6;
+```
+
+`myVar` тепер матиме значення `6`.
+# --instructions--
+
+Змініть `0` так, щоб сума дорівнювала `12`.
+
+# --hints--
+
+Змінна `difference` має дорівнювати 12.
+
+```js
+assert(difference === 12);
+```
+
+Потрібно відняти лише одне число від 45.
+
+```js
+assert(/difference=45-33;?/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'difference = '+z;})(difference);
+```
+
+## --seed-contents--
+
+```js
+const difference = 45 - 0;
+```
+
+# --solutions--
+
+```js
+const difference = 45 - 33;
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
new file mode 100644
index 00000000000..8a83b57e50c
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md
@@ -0,0 +1,98 @@
+---
+id: 567af2437cbaa8c51670a16c
+title: Тестування властивостей об'єктів
+challengeType: 1
+forumTopicId: 18324
+dashedName: testing-objects-for-properties
+---
+
+# --description--
+
+Іноді варто перевіряти чи даний об'єкт вже має певні властивості. Ми можемо використовувати метод об'єктів `.hasOwnProperty(propname)`, щоб визначити чи об'єкт має ім'я властивості. `.hasOwnProperty()` показує `true` чи `false`, в залежності чи властивість знайдена, чи ні.
+
+**Наприклад**
+
+```js
+const myObj = {
+ top: "hat",
+ bottom: "pants"
+};
+
+myObj.hasOwnProperty("top");
+myObj.hasOwnProperty("middle");
+```
+
+Перший `hasOwnProperty` стає `true`, а другий - `false`.
+
+# --instructions--
+
+Змініть функцію `checkObj`, щоб перевірити чи об'єкт переданий до функції (`obj`) містить особливу властивість (`checkProp`). Якщо властивість знайдена, поверніть значення властивості. Якщо ні, поверніть `"Not Found"`.
+
+# --hints--
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "gift")` має повернути рядок `pony`.
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'gift') === 'pony'
+);
+```
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "pet")` має повернути рядок `kitten`.
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'pet') === 'kitten'
+);
+```
+
+`checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "house")` має повернути рядок `Not Found`.
+
+```js
+assert(
+ checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'house') ===
+ 'Not Found'
+);
+```
+
+`checkObj({city: "Seattle"}, "city")` має повернути рядок `Seattle`.
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'city') === 'Seattle');
+```
+
+`checkObj({city: "Seattle"}, "district")` має повернути рядок `Not Found`.
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'district') === 'Not Found');
+```
+
+`checkObj({pet: "kitten", bed: "sleigh"}, "gift")` має повернути рядок `Not Found`.
+
+```js
+assert(checkObj({ pet: 'kitten', bed: 'sleigh' }, 'gift') === 'Not Found');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkObj(obj, checkProp) {
+ // Only change code below this line
+ return "Change Me!";
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function checkObj(obj, checkProp) {
+ if(obj.hasOwnProperty(checkProp)) {
+ return obj[checkProp];
+ } else {
+ return "Not Found";
+ }
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
new file mode 100644
index 00000000000..05acda6c646
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md
@@ -0,0 +1,70 @@
+---
+id: 56533eb9ac21ba0edf2244ba
+title: Розуміння нестійкості рядка
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWPVaUR'
+forumTopicId: 18331
+dashedName: understand-string-immutability
+---
+
+# --description--
+
+У JavaScript, `String` значення immutable, означає, що їх не можна буде змінити після створення.
+
+Наприклад, у такому коді:
+
+```js
+let myStr = "Bob";
+myStr[0] = "J";
+```
+
+неможливо змінити значення `myStr` на `Job`, тому що вміст `myStr` не може бути зміненим. Зауважте, що *not* означає, що `myStr` не можна змінити, так само як окремі елементи в коді string literal. Єдиний спосіб змінити `myStr` - це додати новий рядок:
+
+```js
+let myStr = "Bob";
+myStr = "Job";
+```
+
+# --instructions--
+
+Виправте призначення `myStr` так, щоб код містив рядок зі значенням `Hello World`, використовуючи підхід, показаний вище.
+
+# --hints--
+
+`myStr` має мати значення рядка `Hello World`.
+
+```js
+assert(myStr === 'Hello World');
+```
+
+Не слід змінювати код над зазначеним коментарем.
+
+```js
+assert(/myStr = "Jello World"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return "myStr = " + v;})(myStr);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let myStr = "Jello World";
+
+// Only change code below this line
+myStr[0] = "H"; // Change this line
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+let myStr = "Jello World";
+myStr = "Hello World";
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
new file mode 100644
index 00000000000..a9fc89baebe
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md
@@ -0,0 +1,60 @@
+---
+id: bd7123c9c441eddfaeb5bdef
+title: Розуміння булевих значень
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9Me8t4'
+forumTopicId: 301176
+dashedName: understanding-boolean-values
+---
+
+# --description--
+
+Інший тип даних це Boolean. Булеві значення можуть мати лише два значення: `true` чи `false`. Фактично, це маленькі перемикачі, де `true` це "увімкнено" і `false` - "вимкнено". Ці два стани несумісні.
+
+**Note:** Булеві вирази ніколи не записуються в дужках. Рядки `"true"` й `"false"` не булеві і не мають особливого значення в JavaScript.
+
+# --instructions--
+
+Змініть функцію `welcomeToBooleans` так, щоб вона повертала `true` замість `false`, коли натискається кнопка запуску.
+
+# --hints--
+
+Функція `welcomeToBooleans()` має повернути значення (`true` or `false`).
+
+```js
+assert(typeof welcomeToBooleans() === 'boolean');
+```
+
+`welcomeToBooleans()` має повернути `true`.
+
+```js
+assert(welcomeToBooleans() === true);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+welcomeToBooleans();
+```
+
+## --seed-contents--
+
+```js
+function welcomeToBooleans() {
+ // Only change code below this line
+
+ return false; // Change this line
+
+ // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function welcomeToBooleans() {
+ return true; // Change this line
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
new file mode 100644
index 00000000000..19a7875014d
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md
@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244ab
+title: Розуміння врахування регістру в змінних
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd6GDcD'
+forumTopicId: 18334
+dashedName: understanding-case-sensitivity-in-variables
+---
+
+# --description--
+
+У JavaScript усі змінні та назви функцій існують з урахуванням регістру. Це означає, що написання з великої літери має значення.
+
+`MYVAR` - це не теж саме, що й `MyVar` чи `myvar`. Цілком можливо мати декілька різних змінних з одинаковою назвою, але різним відмінком. Наполегливо рекомендується, щоб, заради чіткості, ви *не* використовували цю мовну особливість.
+
+**Найкраща практика**
+
+Напишіть назви змінних у JavaScript в camelCase. У camelCase, у назвах змінних, які складаються з декількох слів, перше слово ми пишемо з малої букви, а першу букву кожного наступного слова - з великої.
+
+**Приклади:**
+
+```js
+var someVariable;
+var anotherVariableName;
+var thisVariableNameIsSoLong;
+```
+
+# --instructions--
+
+Модифікуйте існуючі оголошення та завдання так, щоб їхні назви використовували camelCase.
+
+Не створюйте жодних нових змінних.
+
+# --hints--
+
+`studlyCapVar` має бути визначене і мати значення `10`.
+
+```js
+assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
+```
+
+`properCamelCase` має бути визначене і мати значення рядка `A String`.
+
+```js
+assert(
+ typeof properCamelCase !== 'undefined' && properCamelCase === 'A String'
+);
+```
+
+`titleCaseOver` має бути визначене і мати значення `9000`.
+
+```js
+assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
+```
+
+`studlyCapVar` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+
+```js
+assert(code.match(/studlyCapVar/g).length === 2);
+```
+
+`properCamelCase` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+
+```js
+assert(code.match(/properCamelCase/g).length === 2);
+```
+
+`titleCaseOver` має використовувати camelCase як в оголошенні, так і в розділах завдань.
+
+```js
+assert(code.match(/titleCaseOver/g).length === 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Variable declarations
+var StUdLyCapVaR;
+var properCamelCase;
+var TitleCaseOver;
+
+// Variable assignments
+STUDLYCAPVAR = 10;
+PRoperCAmelCAse = "A String";
+tITLEcASEoVER = 9000;
+```
+
+# --solutions--
+
+```js
+var studlyCapVar;
+var properCamelCase;
+var titleCaseOver;
+
+studlyCapVar = 10;
+properCamelCase = "A String";
+titleCaseOver = 9000;
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
new file mode 100644
index 00000000000..1da37c8da7a
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md
@@ -0,0 +1,96 @@
+---
+id: 598e8944f009e646fc236146
+title: Розуміння невизначеного значення, яке повернуто з функції
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2p7cL'
+forumTopicId: 301177
+dashedName: understanding-undefined-value-returned-from-a-function
+---
+
+# --description--
+
+Функція може містити команду `return`, але не обов'язково. У цьому випадку функція не має команди `return`. Натомість, коли ви викликаєте її, функція обробляє внутрішній код, але повернене значення є `undefined`.
+
+**Приклад**
+
+```js
+let sum = 0;
+
+function addSum(num) {
+ sum = sum + num;
+}
+
+addSum(3);
+```
+
+`addSum` - це функція без команди `return`. Функція змінить загальну `sum` (суму) змінної, але повернене значення функції буде `undefined`.
+
+# --instructions--
+
+Створіть функцію `addFive` без аргументів. Ця функція додає 5 до `sum` (суми) змінної, але повернене значення є `undefined`.
+
+# --hints--
+
+`addFive` має бути функцією.
+
+```js
+assert(typeof addFive === 'function');
+```
+
+Після запуску обидвох функцій, `sum` має дорівнювати `8`.
+
+```js
+assert(sum === 8);
+```
+
+Повернене з `addFive` значення, має бути `undefined`.
+
+```js
+assert(addFive() === undefined);
+```
+
+Всередині функції `addFive` вам слід додати `5` до `sum` змінної.
+
+```js
+assert(
+ __helpers.removeWhiteSpace(addFive.toString()).match(/sum=sum\+5|sum\+=5/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+let sum = 0;
+
+function addThree() {
+ sum = sum + 3;
+}
+
+// Only change code below this line
+
+
+// Only change code above this line
+
+addThree();
+addFive();
+```
+
+# --solutions--
+
+```js
+let sum = 0;
+
+function addThree() {
+ sum = sum + 3;
+}
+
+function addFive() {
+ sum = sum + 5;
+}
+
+addThree();
+addFive();
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
new file mode 100644
index 00000000000..e223322dce0
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md
@@ -0,0 +1,79 @@
+---
+id: 56533eb9ac21ba0edf2244aa
+title: Розуміння неініціалізованих змінних
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBa2JAL'
+forumTopicId: 18335
+dashedName: understanding-uninitialized-variables
+---
+
+# --description--
+
+Коли змінні JavaScript проголошено, вони мають початкове значення `undefined`. Якщо ви виконуєте математичну дію з `undefined` змінної, вашим результатом буде `NaN`, що означає "Not a Number". Якщо ви об'єднаєте рядок з `undefined` змінною, ви отримаєте рядок літерала з `undefined`.
+
+# --instructions--
+
+Ініціалізуйте три змінні `a`, `b` та `c` відповідно з `5`, `10` і `"I am a"`, щоб вони не були `undefined`.
+
+# --hints--
+
+`a` має бути визначене й обчислене, щоб мати значення `6`.
+
+```js
+assert(typeof a === 'number' && a === 6);
+```
+
+`b` має бути визначене й обчислене, щоб мати значення `15`.
+
+```js
+assert(typeof b === 'number' && b === 15);
+```
+
+`c` не має містити `undefined` і повинне мати значення рядка `I am a String!`
+
+```js
+assert(!/undefined/.test(c) && c === 'I am a String!');
+```
+
+Вам не слід змінювати код під зазначеним коментарем.
+
+```js
+assert(
+ /a = a \+ 1;/.test(code) &&
+ /b = b \+ 5;/.test(code) &&
+ /c = c \+ " String!";/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = '" + c + "'"; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+var a;
+var b;
+var c;
+// Only change code above this line
+
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
+
+# --solutions--
+
+```js
+var a = 5;
+var b = 10;
+var c = "I am a";
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
new file mode 100644
index 00000000000..a0347bfbfb2
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md
@@ -0,0 +1,78 @@
+---
+id: 56bbb991ad1ed5201cd392d1
+title: Оновлення властивостей об'єкта
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yEJT4'
+forumTopicId: 18336
+dashedName: updating-object-properties
+---
+
+# --description--
+
+Після того, як ви створили об'єкт JavaScript, ви можете оновити його властивості в будь-який час, так як і будь-які інші його змінні. Ви можете використовувати точкову або дужкову нотацію для оновлення.
+
+Наприклад, погляньмо на `ourDog`:
+
+```js
+const ourDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+};
+```
+
+Оскільки це винятково щасливий собака, змінімо його ім'я на рядок `Happy Camper`. Ось як ми оновимо властивість імені його об'єкта: `ourDog.name = "Happy Camper";` або `ourDog["name"] = "Happy Camper";` Тепер коли ми оцінюємо `ourDog.name`, замість того, щоб отримати `Camper`, ми отримаємо його нове ім'я `Happy Camper`.
+
+# --instructions--
+
+Оновити властивість імені об'єкта `myDog`. Змінімо його ім'я з `Coder` на `Happy Coder`. Ви можете використовувати точкову або крапкову нотацію.
+
+# --hints--
+
+Вам слід оновити властивість `name` `myDog`, щоб вона дорівнювала рядку`Happy Coder`.
+
+```js
+assert(/happy coder/gi.test(myDog.name));
+```
+
+Не слід змінювати визначення `myDog`.
+
+```js
+assert(/"name": "Coder"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myDog = {
+ "name": "Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+ "name": "Coder",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["freeCodeCamp Campers"]
+};
+myDog.name = "Happy Coder";
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
new file mode 100644
index 00000000000..b9a1e2cacc7
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md
@@ -0,0 +1,74 @@
+---
+id: bd7123c9c549eddfaeb5bdef
+title: Використовуйте Дужкову Нотацію для Пошуку Першого Символу в Рядку
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8JwhW'
+forumTopicId: 18341
+dashedName: use-bracket-notation-to-find-the-first-character-in-a-string
+---
+
+# --description--
+
+Дужкова нотація - це спосіб отримання символу з певним індексом в рядку.
+
+Більшість сучасних мов програмування, таких як JavaScript, не починають рахувати з 1, як це роблять люди. Вони починають з 0. Це називають індексація на основі нуля.
+
+Наприклад, символ з індексом 0 у слові `Charles` буде `C`. Отже, якщо `const firstName = "Charles"`, ви можете отримати значення першої літери рядка, використовуючи `firstName[0]`.
+
+Наприклад:
+
+```js
+const firstName = "Charles";
+const firstLetter = firstName[0];
+```
+
+`firstLetter` повинна мати значення рядка `C`.
+
+# --instructions--
+
+Використовуйте дужкову нотацію, щоб знайти перший символ в змінній `lastName` та задайте його до `firstLetterOfLastName`.
+
+**Підказка:**Спробуйте подивитися на приклад вище, якщо застрягли.
+
+# --hints--
+
+Змінна `firstLetterOfLastName` повинна мати значення `L`.
+
+```js
+assert(firstLetterOfLastName === 'L');
+```
+
+Вам слід використовувати дужкову нотацію.
+
+```js
+assert(code.match(/firstLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(firstLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName[0];
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
new file mode 100644
index 00000000000..91bdaba5c81
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c451eddfaeb5bdef
+title: Використовуйте Дужкову Нотацію для Пошуку Останнього Символу в Рядку
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZQGcv'
+forumTopicId: 18342
+dashedName: use-bracket-notation-to-find-the-last-character-in-a-string
+---
+
+# --description--
+
+Щоб отримати останню літеру рядка, ви можете відняти її від довжини рядка.
+
+Наприклад, якщо `const firstName = "Ada"`, ви можете отримати значення останньої літери, використовуючи `firstName[firstName.length - 1]`.
+
+Наприклад:
+
+```js
+const firstName = "Ada";
+const lastLetter = firstName[firstName.length - 1];
+```
+
+`lastLetter` повинна мати значення рядка `a`.
+
+# --instructions--
+
+Використовуйте дужкову нотацію, щоб знайти останній символ у змінній `lastName`.
+
+**Підказка:**Спробуйте подивитися на приклад вище, якщо застрягли.
+
+# --hints--
+
+`lastLetterOfLastName` повинно бути літерою `e`.
+
+```js
+assert(lastLetterOfLastName === 'e');
+```
+
+Вам слід використовувати `.length`, щоб отримати останню літеру.
+
+```js
+assert(code.match(/\.length/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(lastLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const lastName = "Lovelace";
+
+// Only change code below this line
+const lastLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+const lastName = "Lovelace";
+const lastLetterOfLastName = lastName[lastName.length - 1];
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
new file mode 100644
index 00000000000..687917e223d
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c450eddfaeb5bdef
+title: Використовуйте Дужкову Нотацію для Пошуку N-го Символу в Рядку
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWPVJua'
+forumTopicId: 18343
+dashedName: use-bracket-notation-to-find-the-nth-character-in-a-string
+---
+
+# --description--
+
+Ви можете також використовувати дужкову нотацію, щоб отримати символ на інших позиціях в рядку.
+
+Пам'ятайте, що комп'ютер починає рахувати з `0`, тому перший символ є в дійсності нульовим.
+
+Наприклад:
+
+```js
+const firstName = "Ada";
+const secondLetterOfFirstName = firstName[1];
+```
+
+`secondLetterOfFirstName` повинна мати значення рядка `d`.
+
+# --instructions--
+
+Спробуйте встановити `thirdLetterOfLastName` на рівні третьої літери змінної `lastName`, використовуючи дужкову нотацію.
+
+**Підказка:** Спробуйте подивитися на приклад вище, якщо застрягли.
+
+# --hints--
+
+Змінна `thirdLetterOfLastName` повинна мати значення `v`.
+
+```js
+assert(thirdLetterOfLastName === 'v');
+```
+
+Вам слід використовувати дужкову нотацію.
+
+```js
+assert(code.match(/thirdLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(thirdLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const lastName = "Lovelace";
+
+// Only change code below this line
+const thirdLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+const lastName = "Lovelace";
+const thirdLetterOfLastName = lastName[2];
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
new file mode 100644
index 00000000000..2f0dd284938
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.md
@@ -0,0 +1,68 @@
+---
+id: bd7123c9c452eddfaeb5bdef
+title: Використовуйте Дужкову Нотацію для Пошуку Символу N-го до Останнього в Рядку
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cw4vkh9'
+forumTopicId: 18344
+dashedName: use-bracket-notation-to-find-the-nth-to-last-character-in-a-string
+---
+
+# --description--
+
+Ви можете використовувати той самий принцип, який ми використовували для отримання останнього символу в рядку, щоб отримати символ N-го до останнього.
+
+Наприклад, ви можете отримати значення третьої до останньої літери рядка `const firstName = "Augusta"`, використовуючи `firstName[firstName.length - 3]`
+
+Наприклад:
+
+```js
+const firstName = "Augusta";
+const thirdToLastLetter = firstName[firstName.length - 3];
+```
+
+`thirdToLastLetter` повинен мати значення рядка `s`.
+
+# --instructions--
+
+Використовуйте дужкову нотацію для пошуку передостаннього символу в `lastName` в рядку.
+
+**Підказка:**Спробуйте подивитися на приклад вище, якщо застрягли.
+
+# --hints--
+
+`secondToLastLetterOfLastName` повинно бути літерою `c`.
+
+```js
+assert(secondToLastLetterOfLastName === 'c');
+```
+
+Вам слід використовувати `.length`, щоб отримати передостанню літеру.
+
+```js
+assert(code.match(/\.length/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(secondToLastLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const lastName = "Lovelace";
+
+// Only change code below this line
+const secondToLastLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+const lastName = "Lovelace";
+const secondToLastLetterOfLastName = lastName[lastName.length - 2];
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
new file mode 100644
index 00000000000..061591522db
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-conditional-logic-with-if-statements.md
@@ -0,0 +1,98 @@
+---
+id: cf1111c1c12feddfaeb3bdef
+title: Використання умовної логіки з командою if
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87mf3'
+forumTopicId: 18348
+dashedName: use-conditional-logic-with-if-statements
+---
+
+# --description--
+
+команди `If` використовуються для прийняття рішень у коді. Ключове слово `if` наказує JavaScript виконати код у фігурних дужках за певних умов, вказаних у круглих дужках. Ці умови ще називаються умовами `Boolean` і вони можуть бути лише `true` або `false`.
+
+Коли умова є оціненою як `true`, програма виконує команду у фігурних дужках. Коли булева умова є оцінена як `false`, команда у фігурних дужках не буде виконана.
+
+**Псевдокод**
+
+якщо (condition is true) {
statement is executed
}
+
+**Наприклад:**
+
+```js
+function test (myCondition) {
+ if (myCondition) {
+ return "It was true";
+ }
+ return "It was false";
+}
+
+test(true);
+test(false);
+```
+
+`test(true)` повертає рядок `It was true`, а `test(false)` повертає рядок `It was false`.
+
+Коли `test` отримує значення `true`, оператор `if` оцінює `myCondition`, щоб побачити чи воно є `true` чи ні. Оскільки це `true`, функція повертає `It was true`. Коли `test` отримує значення `false`, `myCondition` є *not* `true`, команда у фігурних дужках не виконується і функція повертає `It was false`.
+
+# --instructions--
+
+Створіть оператора `if` всередині функції, щоб повернути `Yes, that was true`, якщо параметр `wasThatTrue` є `true` та повернути `No, that was false` у протилежному випадку.
+
+# --hints--
+
+`trueOrFalse` повинен бути функцією
+
+```js
+assert(typeof trueOrFalse === 'function');
+```
+
+`trueOrFalse(true)` повинен повертати рядок
+
+```js
+assert(typeof trueOrFalse(true) === 'string');
+```
+
+`trueOrFalse(false)` повинен повертати рядок
+
+```js
+assert(typeof trueOrFalse(false) === 'string');
+```
+
+`trueOrFalse(true)` повинен повернути рядок `Yes, that was true`
+
+```js
+assert(trueOrFalse(true) === 'Yes, that was true');
+```
+
+`trueOrFalse(false)` повинен повернути рядок `No, that was false`
+
+```js
+assert(trueOrFalse(false) === 'No, that was false');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function trueOrFalse(wasThatTrue) {
+ // Only change code below this line
+
+
+
+ // Only change code above this line
+
+}
+```
+
+# --solutions--
+
+```js
+function trueOrFalse(wasThatTrue) {
+ if (wasThatTrue) {
+ return "Yes, that was true";
+ }
+ return "No, that was false";
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
new file mode 100644
index 00000000000..edabeb0f1a2
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-multiple-conditional-ternary-operators.md
@@ -0,0 +1,96 @@
+---
+id: 587d7b7e367417b2b2512b21
+title: Використання декількох умовних (трикомпонентних) операторів
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cyWJBT4'
+forumTopicId: 301179
+dashedName: use-multiple-conditional-ternary-operators
+---
+
+# --description--
+
+У попередньому завданні ви використовували одинарний умовний оператор. Ви також можете їх об'єднати для того, щоб перевірити декілька умов.
+
+Наступна функція використовує `if`, `else if`, а також `else` твердження, щоб перевірити декілька умов:
+
+```js
+function findGreaterOrEqual(a, b) {
+ if (a === b) {
+ return "a and b are equal";
+ }
+ else if (a > b) {
+ return "a is greater";
+ }
+ else {
+ return "b is greater";
+ }
+}
+```
+
+Вказану вище функцію можна переписати, використовуючи декілька умовних операторів:
+
+```js
+function findGreaterOrEqual(a, b) {
+ return (a === b) ? "a and b are equal"
+ : (a > b) ? "a is greater"
+ : "b is greater";
+}
+```
+
+Найкращою практикою вважають відформатування декількох умовних операторів таким чином, що кожна умова буде знаходитися в окремому рядку, як вказано вище. Використання декількох умовних операторів без правильних відступів може ускладнити читання вашого коду. Наприклад:
+
+```js
+function findGreaterOrEqual(a, b) {
+ return (a === b) ? "a and b are equal" : (a > b) ? "a is greater" : "b is greater";
+}
+```
+
+# --instructions--
+
+У функції `checkSign`, використовуйте декілька умовних операторів, дотримуючись рекомендованого формату, що використаний у `findGreaterOrEqual` - для того, щоб перевірити чи число додатнє, від'ємне або нуль. Функція має повернути `positive`, `negative` or `zero`.
+
+# --hints--
+
+`checkSign` має використовувати декілька умовних операторів
+
+```js
+assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?\s*?\?\s*?.+?\s*?:\s*?.+?/gi.test(code));
+```
+
+`checkSign(10)` має повернути рядок `positive`. Зверніть увагу на те, що написання з великої літери - важливе
+
+```js
+assert(checkSign(10) === 'positive');
+```
+
+`checkSign(-12)` має повернути рядок `negative`. Зверніть увагу на те, що написання з великої літери - важливе
+
+```js
+assert(checkSign(-12) === 'negative');
+```
+
+`checkSign(0)` має повернути рядок `zero`. Зверніть увагу на те, що написання з великої літери - важливе
+
+```js
+assert(checkSign(0) === 'zero');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkSign(num) {
+
+}
+
+checkSign(10);
+```
+
+# --solutions--
+
+```js
+function checkSign(num) {
+ return (num > 0) ? 'positive' : (num < 0) ? 'negative' : 'zero';
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
new file mode 100644
index 00000000000..7c322089104
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-countdown.md
@@ -0,0 +1,92 @@
+---
+id: 5cd9a70215d3c4e65518328f
+title: Використовуйте рекурсію для створення зворотного відліку
+challengeType: 1
+forumTopicId: 305925
+dashedName: use-recursion-to-create-a-countdown
+---
+
+# --description--
+
+У [попередньому завданні](/learn/javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion) ви навчилися використовувати рекурсію для заміни циклу `for`. Тепер подивимося на більш складну функцію, яка повертає масив послідовних чисел, починаючи з `1` до числа, переданого функції.
+
+Як уже було згадано в попередньому завданні, це буде base case. Він повідомляє рекурсивній функції, коли їй більше не потрібно викликати саму себе. Це простий випадок, коли значення, яке повертається, вже відоме. Також існує recursive call, який виконує початкову функцію з різними параметрами. Якщо функція написана правильно, то буде досягнутий базовий випадок.
+
+Наприклад, скажімо, ви хочете написати рекурсивну функцію, яка повертає масив, що містить числа від `1` до `n`. Цій функції потрібно прийняти параметр `n`, який означає остаточне число. Тоді їй потрібно викликати саму себе, поступово зменшуючи значення числа `n`, поки воно не досягне `1`. Ви можете написати функцію наступним чином:
+
+```javascript
+function countup(n) {
+ if (n < 1) {
+ return [];
+ } else {
+ const countArray = countup(n - 1);
+ countArray.push(n);
+ return countArray;
+ }
+}
+console.log(countup(5));
+```
+
+Значення `[1, 2, 3, 4, 5]` будуть відображені на консолі.
+
+Спочатку це може здатися парадоксальним, адже значення `n` *зростає*, але значення у остаточному масиві *зростають*. Так відбувається, тому що підвищення відбувається останнім після рекурсивного виклику. У точці, де `n` вставляється в масив `countup(n - 1)` вже проаналізовано та повернуто `[1, 2, ..., n - 1]`.
+
+# --instructions--
+
+Ми вже визначили функцію під назвою `countdown` з одним параметром (`n`). Функція має використовувати рекурсію, щоб повернути масив, який містить цілі числа від `n` до `1` на основі параметра `n`. Якщо функція викликається числом меншим за 1, вона має повернути порожній масив. Наприклад, виклик цієї функції зі значенням `n = 5` має повернути масив `[5, 4, 3, 2, 1]`. Ваша функція має використовувати рекурсію шляхом виклику самої себе, але не повинна використовувати ніякі цикли.
+
+# --hints--
+
+`countdown(-1)` має повернути пустий масив.
+
+```js
+assert.isEmpty(countdown(-1));
+```
+
+`countdown(10)` має повернути `[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]`
+
+```js
+assert.deepStrictEqual(countdown(10), [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
+```
+
+`countdown(5)` має повернути `[5, 4, 3, 2, 1]`
+
+```js
+assert.deepStrictEqual(countdown(5), [5, 4, 3, 2, 1]);
+```
+
+Ваш код не має опиратися на жодні цикли (`for`, `while` або функції більш високого порядку, такі як `forEach`, `map`, `filter`, and `reduce`).
+
+```js
+assert(
+ !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+Вам слід використати рекурсію, щоб вирішити цю проблему.
+
+```js
+assert(
+ countdown.toString().match(/countdown\s*\(.+\)/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+function countdown(n){
+ return;
+}
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+function countdown(n){
+ return n < 1 ? [] : [n].concat(countdown(n - 1));
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
new file mode 100644
index 00000000000..9c8b6de6624
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-recursion-to-create-a-range-of-numbers.md
@@ -0,0 +1,81 @@
+---
+id: 5cc0bd7a49b71cb96132e54c
+title: Використання рекурсії для створення діапазону чисел
+challengeType: 1
+forumTopicId: 301180
+dashedName: use-recursion-to-create-a-range-of-numbers
+---
+
+# --description--
+
+Продовжуючи попереднє завдання, ми пропонуємо вам ще одну можливість створити рекурсивну функцію для вирішення проблеми.
+
+# --instructions--
+
+Ми визначили функцію під назвою `rangeOfNumbers` з двома параметрами. Функція повинна повернути масив цілих чисел, що починаються з числа, представленого параметром `startNum` і закінчується числом, яке представлене параметром `endNum`. Початкове число завжди буде меншим або рівним кінцевому номеру. Ваша функція має використовувати рекурсію, викликаючи сама себе, але не повинна використовувати якісь цикли. Вона також повинна працювати у випадках, коли`startNum` і `endNum` однакові.
+
+# --hints--
+
+Ваша функція повинна повертати масив.
+
+```js
+assert(Array.isArray(rangeOfNumbers(5, 10)));
+```
+
+У вашому коді не повинні використовуватися ніякі циклічні синтаксичні структури (`for` або `while` або функції вищого порядку, такі як `forEach`, `map`, `filter`, або `reduce`).
+
+```js
+assert(
+ !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+`rangeOfNumbers` повинен використовувати рекурсію (викликати самого себе) для вирішення цьгого завдання.
+
+```js
+assert(
+ rangeOfNumbers.toString().match(/rangeOfNumbers\s*\(.+\)/)
+);
+```
+
+`rangeOfNumbers(1, 5)` повинен повертати `[1, 2, 3, 4, 5]`.
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(1, 5), [1, 2, 3, 4, 5]);
+```
+
+`rangeOfNumbers(6, 9)` повинен повертати `[6, 7, 8, 9]`.
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(6, 9), [6, 7, 8, 9]);
+```
+
+`rangeOfNumbers(4, 4)` повинен повертати `[4]`.
+
+```js
+assert.deepStrictEqual(rangeOfNumbers(4, 4), [4]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function rangeOfNumbers(startNum, endNum) {
+ return [];
+};
+```
+
+# --solutions--
+
+```js
+function rangeOfNumbers(startNum, endNum) {
+ if (endNum - startNum === 0) {
+ return [startNum];
+ } else {
+ const numbers = rangeOfNumbers(startNum, endNum - 1);
+ numbers.push(endNum);
+ return numbers;
+ }
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
new file mode 100644
index 00000000000..3c68b6d5ab3
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-conditional-ternary-operator.md
@@ -0,0 +1,84 @@
+---
+id: 587d7b7e367417b2b2512b24
+title: Використання умовного (трикомпонентного) оператора
+challengeType: 1
+forumTopicId: 301181
+dashedName: use-the-conditional-ternary-operator
+---
+
+# --description--
+
+Умовний оператор, який також називається трикомпонентним оператором, може використовуватися як однорядковий "if-else" вираз.
+
+Синтаксисом є `a ? b : c`, де `a` - це умова, `b` - це код, що запускається, коли умова повертає `true` і `c` - код, що запускається, коли умова повертає `false`.
+
+Ця функція використовує `if/else` твердження для того, щоб перевірити умову:
+
+```js
+function findGreater(a, b) {
+ if(a > b) {
+ return "a is greater";
+ }
+ else {
+ return "b is greater or equal";
+ }
+}
+```
+
+Її можна переписати, використовуючи умовний оператор:
+
+```js
+function findGreater(a, b) {
+ return a > b ? "a is greater" : "b is greater or equal";
+}
+```
+
+# --instructions--
+
+Використовуйте умовний оператор у функції `checkEqual`, щоб перевірити чи два числа рівні, чи ні. Функція має повернути рядок `Equal` або рядок `Not Equal`.
+
+# --hints--
+
+`checkEqual` має використовувати умовний оператор
+
+```js
+assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?/.test(code));
+```
+
+`checkEqual(1, 2)` має повернути рядок `Not Equal`
+
+```js
+assert(checkEqual(1, 2) === 'Not Equal');
+```
+
+`checkEqual(1, 1)` має повернути рядок `Equal`
+
+```js
+assert(checkEqual(1, 1) === 'Equal');
+```
+
+`checkEqual(1, -1)` має повернути рядок `Not Equal`
+
+```js
+assert(checkEqual(1, -1) === 'Not Equal');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkEqual(a, b) {
+
+}
+
+checkEqual(1, 2);
+```
+
+# --solutions--
+
+```js
+function checkEqual(a, b) {
+ return a === b ? "Equal" : "Not Equal";
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
new file mode 100644
index 00000000000..6122e32ee71
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md
@@ -0,0 +1,82 @@
+---
+id: 587d7b7e367417b2b2512b22
+title: Використайте функцію ParseInt з радіусом
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6K4Kh3'
+forumTopicId: 301182
+dashedName: use-the-parseint-function-with-a-radix
+---
+
+# --description--
+
+Функція `parseInt()` аналізує рядок і повертає ціле число. Для радікса потрібен другий аргумент, який визначає основу числа у рядку. Радіксом може бути ціле число від 2 до 36.
+
+Виклик функції виглядає так:
+
+```js
+parseInt(string, radix);
+```
+
+Ось приклад:
+
+```js
+const a = parseInt("11", 2);
+```
+
+Змінна радікса говорить, що `11` знаходиться у двійковій системі або у базі 2. Цей приклад перетворює рядок `11` на ціле число `3`.
+
+# --instructions--
+
+Використовуйте `parseInt()` у функції `convertToInteger`, щоб воно перетворило двійкове число на ціле число і повернуло його.
+
+# --hints--
+
+`convertToInteger` має використати функцію `parseInt()`
+
+```js
+assert(/parseInt/g.test(code));
+```
+
+`convertToInteger("10011")` має повернути число
+
+```js
+assert(typeof convertToInteger('10011') === 'number');
+```
+
+`convertToInteger("10011")` має повернути 19
+
+```js
+assert(convertToInteger('10011') === 19);
+```
+
+`convertToInteger("111001")` має повернути 57
+
+```js
+assert(convertToInteger('111001') === 57);
+```
+
+`convertToInteger("JamesBond")` має повернути `NaN`
+
+```js
+assert.isNaN(convertToInteger('JamesBond'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToInteger(str) {
+
+}
+
+convertToInteger("10011");
+```
+
+# --solutions--
+
+```js
+function convertToInteger(str) {
+ return parseInt(str, 2);
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
new file mode 100644
index 00000000000..6aba56ffb0a
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md
@@ -0,0 +1,74 @@
+---
+id: 587d7b7e367417b2b2512b23
+title: Використовуйте Функцію parseInt
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm83LSW'
+forumTopicId: 301183
+dashedName: use-the-parseint-function
+---
+
+# --description--
+
+Функція `parseInt()` аналізує рядок і повертає ціле число. Наприклад:
+
+```js
+const a = parseInt("007");
+```
+
+Наведена вище функція перетворює рядок `007` у ціле `7`. Якщо перший символ у рядку не може бути перетвореним у число, тоді він повертає `NaN`.
+
+# --instructions--
+
+Використовуйте `parseInt()` у функції `convertToInteger`, щоб вона конвертувала вхідний рядок `str` у ціле число та повернула його.
+
+# --hints--
+
+`convertToInteger` має використати функцію `parseInt()`
+
+```js
+assert(/parseInt/g.test(code));
+```
+
+`convertToInteger("56")` має повернути число
+
+```js
+assert(typeof convertToInteger('56') === 'number');
+```
+
+`convertToInteger("56")` має повернути 56
+
+```js
+assert(convertToInteger('56') === 56);
+```
+
+`convertToInteger("77")` має повернути 77
+
+```js
+assert(convertToInteger('77') === 77);
+```
+
+`convertToInteger("JamesBond")` має повернути `NaN`
+
+```js
+assert.isNaN(convertToInteger('JamesBond'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function convertToInteger(str) {
+
+}
+
+convertToInteger("56");
+```
+
+# --solutions--
+
+```js
+function convertToInteger(str) {
+ return parseInt(str);
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
new file mode 100644
index 00000000000..09fc1f0f21c
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/using-objects-for-lookups.md
@@ -0,0 +1,155 @@
+---
+id: 56533eb9ac21ba0edf2244ca
+title: Використання об'єктів для пошуків
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBk8sM'
+forumTopicId: 18373
+dashedName: using-objects-for-lookups
+---
+
+# --description--
+
+Об'єкти можна вважати сховищем ключів та значень, як словники. Якщо ви маєте табличні дані, ви краще можете використати об'єкт для пошуку значень, ніж `switch` твердження або `if/else` ланцюжок. Це найбільш корисно, коли ви знаєте, що ваші вхідні дані обмежені до певного діапазону.
+
+Ось приклад простого пошуку алфавіту в зворотньому порядку:
+
+```js
+const alpha = {
+ 1:"Z",
+ 2:"Y",
+ 3:"X",
+ 4:"W",
+ ...
+ 24:"C",
+ 25:"B",
+ 26:"A"
+};
+
+alpha[2];
+alpha[24];
+
+const value = 2;
+alpha[value];
+```
+
+`alpha[2]` - це рядок `Y`, `alpha[24]` - це рядок `C`, а `alpha[value]` - це рядок `Y`.
+
+# --instructions--
+
+Переробіть ключове твердження на об'єкт, що називається `lookup`. Використовуйте його, щоб шукати `val` і призначати пов'язаний рядок до `result` змінної.
+
+# --hints--
+
+`phoneticLookup("alpha")` має дорівнювати рядку `Adams`
+
+```js
+assert(phoneticLookup('alpha') === 'Adams');
+```
+
+`phoneticLookup("bravo")` має дорівнювати рядку `Boston`
+
+```js
+assert(phoneticLookup('bravo') === 'Boston');
+```
+
+`phoneticLookup("charlie")` має дорівнювати рядку `Chicago`
+
+```js
+assert(phoneticLookup('charlie') === 'Chicago');
+```
+
+`phoneticLookup("delta")` має дорівнювати рядку `Denver`
+
+```js
+assert(phoneticLookup('delta') === 'Denver');
+```
+
+`phoneticLookup("echo")` має дорівнювати рядку `Easy`
+
+```js
+assert(phoneticLookup('echo') === 'Easy');
+```
+
+`phoneticLookup("foxtrot")` має дорівнювати рядку `Frank`
+
+```js
+assert(phoneticLookup('foxtrot') === 'Frank');
+```
+
+`phoneticLookup("")` має дорівнювати `undefined`
+
+```js
+assert(typeof phoneticLookup('') === 'undefined');
+```
+
+Вам не слід змінювати `return` твердження
+
+```js
+assert(code.match(/return\sresult;/));
+```
+
+Вам не слід використовувати `case`, `switch` або `if` твердження
+
+```js
+assert(
+ !/case|switch|if/g.test(code.replace(/([/]{2}.*)|([/][*][^/*]*[*][/])/g, ''))
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function phoneticLookup(val) {
+ let result = "";
+
+ // Only change code below this line
+ switch(val) {
+ case "alpha":
+ result = "Adams";
+ break;
+ case "bravo":
+ result = "Boston";
+ break;
+ case "charlie":
+ result = "Chicago";
+ break;
+ case "delta":
+ result = "Denver";
+ break;
+ case "echo":
+ result = "Easy";
+ break;
+ case "foxtrot":
+ result = "Frank";
+ }
+
+ // Only change code above this line
+ return result;
+}
+
+phoneticLookup("charlie");
+```
+
+# --solutions--
+
+```js
+function phoneticLookup(val) {
+ let result = "";
+
+ const lookup = {
+ alpha: "Adams",
+ bravo: "Boston",
+ charlie: "Chicago",
+ delta: "Denver",
+ echo: "Easy",
+ foxtrot: "Frank"
+ };
+
+ result = lookup[val];
+
+ return result;
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
new file mode 100644
index 00000000000..5e18338737f
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/word-blanks.md
@@ -0,0 +1,107 @@
+---
+id: 56533eb9ac21ba0edf2244bb
+title: Пропуски у словах
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caqn8zuP'
+forumTopicId: 18377
+dashedName: word-blanks
+---
+
+# --description--
+
+Тепер ми використаємо наші знання про рядки, щоб створити стильну гру у слова [Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs), яку ми називаємо "Пропуски в словах". Ви створите (за бажанням гумористичні) речення типу "Заповніть пропуски".
+
+У грі "Пропуски в словах", у вас є речення з пропущеними частинами мови, наприклад, іменниками, дієсловами, прикметниками та прислівниками. Потім ви заповнюєте вибрані вами відсутні фрагменти слів так, аби завершене реченням мало сенс.
+
+Розгляньте це речення - Було дуже **\_\_\_\_**, і ми **\_\_\_\_** себе **\_\_\_\_**. У цьому реченні відсутні три фрагменти: прикметник, дієслово та прислівник; ми можемо додати вибрані нами слова для того, щоб завершити його. Потім ми можемо призначити надіслане речення змінній наступним чином:
+
+```js
+const sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";
+```
+
+# --instructions--
+
+У цьому завданні у вас є іменник, дієслово, прикметник та прислівник. Вам потрібно створити завершене речення зі словами на ваш вибір, а також використати ті, які ми надаємо.
+
+Вам потрібно використати рядок оператор конкатенації `+`, щоб створити новий, за допомогою наданих змінних: `myNoun`, `myAdjective`, `myVerb`, і `myAdverb`. Потім ви задасте сформованому рядку змінну `wordBlanks`. Не слід змінювати слова, які зазначені як змінні.
+
+Вам також потрібно враховувати пропуски у вашому рядку для того, щоб кінцеве речення містило пробіли між усіма словами. У результаті ви маєте отримати завершене речення.
+
+# --hints--
+
+`wordBlanks` має бути рядком.
+
+```js
+assert(typeof wordBlanks === 'string');
+```
+
+Ви не повинні змінювати значення, задані як `myNoun`, `myVerb`, `myAdjective` або `myAdverb`.
+
+```js
+assert(
+ myNoun === 'dog' &&
+ myVerb === 'ran' &&
+ myAdjective === 'big' &&
+ myAdverb === 'quickly'
+);
+```
+
+Ви не повинні безпосередньо використовувати змінні `собака`, `біг`, `великий`, або `швидко` для того, щоб створити `wordBlanks`.
+
+```js
+const newCode = removeAssignments(code);
+assert(
+ !/dog/.test(newCode) &&
+ !/ran/.test(newCode) &&
+ !/big/.test(newCode) &&
+ !/quickly/.test(newCode)
+);
+```
+
+`wordBlanks` має містити всі слова, які задані як змінні: `myNoun`, `myVerb`, `myAdjective` і `myAdverb` виокремленими словами, які не є символами (а також будь-якими додатковими словами у вашій madlib).
+
+```js
+assert(
+ /\bdog\b/.test(wordBlanks) &&
+ /\bbig\b/.test(wordBlanks) &&
+ /\bran\b/.test(wordBlanks) &&
+ /\bquickly\b/.test(wordBlanks)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const removeAssignments = str => str
+ .replace(/myNoun\s*=\s*["']dog["']/g, '')
+ .replace(/myAdjective\s*=\s*["']big["']/g, '')
+ .replace(/myVerb\s*=\s*["']ran["']/g, '')
+ .replace(/myAdverb\s*=\s*["']quickly["']/g, '');
+```
+
+## --seed-contents--
+
+```js
+const myNoun = "dog";
+const myAdjective = "big";
+const myVerb = "ran";
+const myAdverb = "quickly";
+
+// Only change code below this line
+const wordBlanks = ""; // Change this line
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const myNoun = "dog";
+const myAdjective = "big";
+const myVerb = "ran";
+const myAdverb = "quickly";
+
+let wordBlanks = "Once there was a " + myNoun + " which was very " + myAdjective + ". ";
+wordBlanks += "It " + myVerb + " " + myAdverb + " around the yard.";
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
new file mode 100644
index 00000000000..81a4e589b09
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-javascript/write-reusable-javascript-with-functions.md
@@ -0,0 +1,101 @@
+---
+id: 56bbb991ad1ed5201cd392cf
+title: Створення багаторазового коду JavaScript за допомогою функцій
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cL6dqfy'
+forumTopicId: 18378
+dashedName: write-reusable-javascript-with-functions
+---
+
+# --description--
+
+У JavaScript, ми можемо розділити наш код на повторно використовувані частини, які називаються functions.
+
+Приклад функції:
+
+```js
+function functionName() {
+ console.log("Hello World");
+}
+```
+
+Ви можете викликати або invoke цю функцію, використавши дужки для написання її назви так: `functionName();`. Щоразу як ви викликатимете функцію, на екран буде виводитись повідомлення з написом `Hello World` на консолі розробника. Щоразу як буде викликана функція, увесь код між фігурними дужками буде виконуватись.
+
+# --instructions--
+
+
+ -
+ Створіть функцію, яка називається
reusableFunction, що друкує рядок Hi World на консоль розробників.
+
+ -
+ Викличте функцію.
+
+
+
+# --hints--
+
+`reusableFunction` повинен бути функцією.
+
+```js
+assert(typeof reusableFunction === 'function');
+```
+
+Якщо `reusableFunction` буде викликано, то він має виводити рядок `Hi World` на консоль.
+
+```js
+assert(testConsole());
+```
+
+Викличте функцію `reusableFunction` після її визначення.
+
+```js
+const functionStr = reusableFunction && __helpers.removeWhiteSpace(reusableFunction.toString());
+const codeWithoutFunction = __helpers.removeWhiteSpace(code).replace(/reusableFunction\(\)\{/g, '');
+assert(/reusableFunction\(\)/.test(codeWithoutFunction));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+
+function testConsole() {
+ var logOutput = "";
+ var originalConsole = console;
+ var nativeLog = console.log;
+ var hiWorldWasLogged = false;
+ console.log = function (message) {
+ if(message === 'Hi World') {
+ console.warn(message)
+ hiWorldWasLogged = true;
+ }
+ if(message && message.trim) logOutput = message.trim();
+ if(nativeLog.apply) {
+ nativeLog.apply(originalConsole, arguments);
+ } else {
+ var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+ nativeLog(nativeMsg);
+ }
+ };
+ reusableFunction();
+ console.log = nativeLog;
+ return hiWorldWasLogged;
+}
+
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function reusableFunction() {
+ console.log("Hi World");
+}
+reusableFunction();
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.md
new file mode 100644
index 00000000000..ca1844da895
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-arguments-passed-in-the-wrong-order-when-calling-a-function.md
@@ -0,0 +1,57 @@
+---
+id: 587d7b85367417b2b2512b3a
+title: Знаходження переданих у неправильному порядку аргументів під час виклику функції
+challengeType: 1
+forumTopicId: 301184
+dashedName: catch-arguments-passed-in-the-wrong-order-when-calling-a-function
+---
+
+# --description--
+
+Продовжуючи обговорення виклику функцій, наступною помилкою може бути пошук аргументів функції, переданих у неправильному порядку. Якщо аргументи відносяться до різних типів, наприклад, функцій з масивами та цілими числами, то це, ймовірно, призведе до помилок в коді. Якщо аргументи відносяться до одного типу (наприклад, усі з них - цілі числа), тоді послідовність коду не матиме сенсу. Переконайтеся, що усі необхідні аргументи розташовано у правильному порядку, щоб уникнути цих проблем.
+
+# --instructions--
+
+Функція `raiseToPower` підносить основу до ступеня. На жаль, його не викликано належним чином - виправіть код так, щоб значення `power` дорівнювало 8.
+
+# --hints--
+
+Ваш код має виправити змінну `power`, щоб вона дорівнювала 2-ом піднесеним до 3 ступеня, а не 3-ом піднесеним до 2 ступеня.
+
+```js
+assert(power == 8);
+```
+
+Ваш код має використовувати правильний порядок аргументів для виклику функції `raiseToPower`.
+
+```js
+assert(code.match(/raiseToPower\(\s*?base\s*?,\s*?exp\s*?\);/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function raiseToPower(b, e) {
+ return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(exp, base);
+console.log(power);
+```
+
+# --solutions--
+
+```js
+function raiseToPower(b, e) {
+ return Math.pow(b, e);
+}
+
+let base = 2;
+let exp = 3;
+let power = raiseToPower(base, exp);
+console.log(power);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.md
new file mode 100644
index 00000000000..16ea3616930
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-missing-open-and-closing-parenthesis-after-a-function-call.md
@@ -0,0 +1,69 @@
+---
+id: 587d7b85367417b2b2512b39
+title: Знаходження пропущених відкриваючих та закриваючих дужок після виклику функції
+challengeType: 1
+forumTopicId: 301185
+dashedName: catch-missing-open-and-closing-parenthesis-after-a-function-call
+---
+
+# --description--
+
+Коли функція чи метод не приймає жодних аргументів, під час їх виклику ви можете забути додати (порожні) відкриваючі та закриваючі дужки. Зазвичай результат виклику функції зберігається у змінних для подальшого використання у вашому коді. Цю помилку можна розпізнати шляхом вводу змінних значень (або їхніх типів) у консоль, поки одне з них не матиме посилання на функцію замість очікуваного значення, яке вона має повертати.
+
+Змінні у поданому нижче прикладі є різними:
+
+```js
+function myFunction() {
+ return "You rock!";
+}
+let varOne = myFunction;
+let varTwo = myFunction();
+```
+
+У випадку `varOne` є функцією `myFunction`, і `varTwo` є рядком `You rock!`.
+
+# --instructions--
+
+Виправте код таким чином, щоб змінна `result` отримала значення, повернене від виклику функції `getNine`.
+
+# --hints--
+
+Ваш код має виправити змінну `result` так, щоб вона була встановлена числом, яке функція `getNine` повертатиме.
+
+```js
+assert(result == 9);
+```
+
+Ваш код має викликати функцію `getNine`.
+
+```js
+assert(code.match(/getNine\(\)/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function getNine() {
+ let x = 6;
+ let y = 3;
+ return x + y;
+}
+
+let result = getNine;
+console.log(result);
+```
+
+# --solutions--
+
+```js
+function getNine() {
+ let x = 6;
+ let y = 3;
+ return x + y;
+}
+
+let result = getNine();
+console.log(result);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.md
new file mode 100644
index 00000000000..b81757b1cda
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-misspelled-variable-and-function-names.md
@@ -0,0 +1,69 @@
+---
+id: 587d7b84367417b2b2512b35
+title: Знаходження неправильно написаних змінних та назв функцій
+challengeType: 1
+forumTopicId: 301186
+dashedName: catch-misspelled-variable-and-function-names
+---
+
+# --description--
+
+Методи `console.log()` та `typeof` є двома основними способами перевірки допоміжних значень та типів вихідних програм. Тепер час заглибитися у найпоширеніші різновиди форм, які можуть приймати помилки. Одна помилка на синтаксичному рівні, яку можна допустити при швидкому друці, є звичайною помилкою правопису.
+
+Якщо символ у змінній чи назві функції буде перенесений, відсутній, або ж матиме неправильний регістр, браузер виконуватиме пошук неіснуючого об'єкта та надсилатиме скарги у формі посилання на помилку. Змінні та назви функцій JavaScript є чутливим до регістру літер.
+
+# --instructions--
+
+Виправте дві помилки правопису в коді, щоб розрахунок `netWorkingCapital` працював.
+
+# --hints--
+
+Перевірте правопис двох змінних, використаних у розрахунку netWorkingCapital, щоб вихідні дані консолі показували "Чистий робочий капітал: 2".
+
+```js
+assert(netWorkingCapital === 2);
+```
+
+У коді не повинно бути жодних випадків змінних, написаних у неправильному регістрі.
+
+```js
+assert(!code.match(/recievables/g));
+```
+
+Змінна `receivables` коду має бути правильно об'явлена і використана.
+
+```js
+assert(code.match(/receivables/g).length == 2);
+```
+
+У коді не повинно бути жодних випадків змінних, написаних у неправильному регістрі.
+
+```js
+assert(!code.match(/payable;/g));
+```
+
+Змінна `payables` коду має бути правильно об'явлена і використана.
+
+```js
+assert(code.match(/payables/g).length == 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = recievables - payable;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```
+
+# --solutions--
+
+```js
+let receivables = 10;
+let payables = 8;
+let netWorkingCapital = receivables - payables;
+console.log(`Net working capital is: ${netWorkingCapital}`);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.md
new file mode 100644
index 00000000000..21a75ab35e3
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-mixed-usage-of-single-and-double-quotes.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b84367417b2b2512b37
+title: Знаходження змішаного використання одинарних та подвійних лапок
+challengeType: 1
+forumTopicId: 301188
+dashedName: catch-mixed-usage-of-single-and-double-quotes
+---
+
+# --description--
+
+У JavaScript дозволяє використання як одинарних (`'`), так і подвійних (`"`) лапок, щоб задати рядок. Вибір між ними залежить від особистих уподобань, проте існують і певні винятки.
+
+Обирати між ними - справді чудово, якщо у рядку наявні скорочення або ж інша його частина вже знаходиться в лапках. Лише будьте уважними, аби не закрити рядок занадто рано, що може призвести до помилки в синтаксисі.
+
+Ось деякі приклади змішаного використанням лапок:
+
+```js
+const grouchoContraction = "I've had a perfectly wonderful evening, but this wasn't it.";
+const quoteInString = "Groucho Marx once said 'Quote me as saying I was mis-quoted.'";
+const uhOhGroucho = 'I've had a perfectly wonderful evening, but this wasn't it.';
+```
+
+Перші два варіанти є правильними, але третій містить помилку.
+
+Звичайно, використання лише одного виду лапок теж є правильним. Уникнути повторення лапок можна використовуючи символ зворотної косої риски (`\`):
+
+```js
+const allSameQuotes = 'I\'ve had a perfectly wonderful evening, but this wasn\'t it.';
+```
+
+# --instructions--
+
+Виправіть рядок шляхом або використання у ньому різних типів лапок для значення `href`, або уникнувши застосування вже наявних. Дотримуйтесь використання подвійних лапок навколо всього рядка.
+
+# --hints--
+
+Ваш код має виправляти використання лапок навколо значення `href` у `#Home` шляхом зміни їхнього типу або уникаючи їх вжитку.
+
+```js
+assert(code.match(//g));
+```
+
+Ваш код має дотримуватися використання подвійних лапок навколо всього рядка.
+
+```js
+assert(code.match(/".*?<\/p>";/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let innerHtml = "
Click here to return home
";
+console.log(innerHtml);
+```
+
+# --solutions--
+
+```js
+let innerHtml = "Click here to return home
";
+console.log(innerHtml);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md
new file mode 100644
index 00000000000..a5d1d4da7f9
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-off-by-one-errors-when-using-indexing.md
@@ -0,0 +1,93 @@
+---
+id: 587d7b86367417b2b2512b3b
+title: Знаходження помилок неврахованої одиниці при індексуванні
+challengeType: 1
+forumTopicId: 301189
+dashedName: catch-off-by-one-errors-when-using-indexing
+---
+
+# --description--
+
+Помилки неврахованої одиниці (також відомі як помилки на одиницю) виникають, коли ви намагаєтеся обрати конкретний індекс рядка чи масиву (для виокремлення чи отримання доступу до цього сегмента) або під час створення з них циклів. Індексування JavaScript починається з нуля, а не одиниці, що означає, що останній індекс завжди буде на одиницю меншим, ніж довжина елемента. Якщо ви спробуєте отримати доступ до індексу рівному довжині, програма повідомить про помилку "індексу поза діапазоном" або виведе на екран результат `undefined`.
+
+Якщо ви використовуєте методи рядка чи масиву, які беруть діапазон індексу за аргумент, прочитання документації допоможе зрозуміти, чи вони включають елементи (коли елемент за заданим індексом є частиною отриманого результату), чи ні. Ось кілька прикладів помилок неврахованої одиниці:
+
+```js
+let alphabet = "abcdefghijklmnopqrstuvwxyz";
+let len = alphabet.length;
+for (let i = 0; i <= len; i++) {
+ console.log(alphabet[i]);
+}
+for (let j = 1; j < len; j++) {
+ console.log(alphabet[j]);
+}
+for (let k = 0; k < len; k++) {
+ console.log(alphabet[k]);
+}
+```
+
+Перший приклад створює цикл забагато разів, а другий цикл є занадто коротким (оскільки пропущений перший індекс, 0). Третій приклад правильний.
+
+# --instructions--
+
+Виправіть дві помилки індексування у поданій функції таким чином, щоб усі числа від 1 до 5 були виведені на консоль.
+
+# --hints--
+
+Ваш код має встановити початкову умову циклу так, щоб він починався з першого індексу.
+
+```js
+assert(code.match(/i\s*?=\s*?0\s*?;/g).length == 1);
+```
+
+Ваш код має виправити початкову умову циклу таким чином, щоб індекс починався з 0.
+
+```js
+assert(!code.match(/i\s?=\s*?1\s*?;/g));
+```
+
+Ваш код має встановити кінцеву умову циклу так, щоб він закінчувався на останньому індексі.
+
+```js
+assert(code.match(/i\s*?<\s*?len\s*?;/g).length == 1);
+```
+
+Ваш код має виправити кінцеву умову циклу таким чином, щоб він зупинявся на 1 перед одиницею довжини.
+
+```js
+assert(!code.match(/i\s*?<=\s*?len;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function countToFive() {
+ let firstFive = "12345";
+ let len = firstFive.length;
+ // Only change code below this line
+ for (let i = 1; i <= len; i++) {
+ // Only change code above this line
+ console.log(firstFive[i]);
+ }
+}
+
+countToFive();
+```
+
+# --solutions--
+
+```js
+function countToFive() {
+ let firstFive = "12345";
+ let len = firstFive.length;
+ // Only change code below this line
+ for (let i = 0; i < len; i++) {
+ // Only change code above this line
+ console.log(firstFive[i]);
+ }
+}
+
+countToFive();
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md
new file mode 100644
index 00000000000..7f6269ca165
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-unclosed-parentheses-brackets-braces-and-quotes.md
@@ -0,0 +1,49 @@
+---
+id: 587d7b84367417b2b2512b36
+title: 'Знаходження незакритих круглих, квадратних і фігурних дужок та лапок'
+challengeType: 1
+forumTopicId: 301190
+dashedName: catch-unclosed-parentheses-brackets-braces-and-quotes
+---
+
+# --description--
+
+Наступна синтаксична помилка, про яку варто пам'ятати - відкривши круглі, квадратні, фігурні дужки або лапки, необхідно їх також закрити. Зазвичай про це можна забути під час редагування вже існуючого коду або вставлення елементів вже з одним з типів парних розділових знаків. Також будьте обережні, коли вкладаєте одні блоки коду в інші, наприклад, додавання зворотного виклику функції в якості аргументу до методу.
+
+Один із способів уникнути цієї помилки - одразу при відкритті лапок або дужок закривайте їх і потім повертайте курсор між парними пунктуаційними знаками та продовжуйте кодування. На щастя, більшість сучасних редакторів коду створюють другу частину пари автоматично.
+
+# --instructions--
+
+Виправте помилки парних знаків у коді.
+
+# --hints--
+
+Ваш код має виправити відсутній фрагмент масиву.
+
+```js
+assert(code.match(/myArray\s*?=\s*?\[\s*?1\s*?,\s*?2\s*?,\s*?3\s*?\];/g));
+```
+
+Ваш код має виправити відсутній фрагмент методу `.reduce()`. Вихідні дані консолі повинні мати результат `Sum of array values is: 6`.
+
+```js
+assert(arraySum === 6);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let myArray = [1, 2, 3;
+let arraySum = myArray.reduce((previous, current => previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
+
+# --solutions--
+
+```js
+let myArray = [1, 2, 3];
+let arraySum = myArray.reduce((previous, current) => previous + current);
+console.log(`Sum of array values is: ${arraySum}`);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md
new file mode 100644
index 00000000000..9b9cd1a12eb
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/catch-use-of-assignment-operator-instead-of-equality-operator.md
@@ -0,0 +1,81 @@
+---
+id: 587d7b85367417b2b2512b38
+title: Спільне використання оператору призначення замість оператору рівності
+challengeType: 1
+forumTopicId: 301191
+dashedName: catch-use-of-assignment-operator-instead-of-equality-operator
+---
+
+# --description--
+
+Розгалуження певних типів програм, які виконують різні дії у разі виконання певних умов, у JavaScript опирається на команди `if`, `else if` та `else`. Інколи такі умови відбуваються у формі перевірки або коли результат дорівнює значенню.
+
+За цією логікою (принаймні в англійській мові), "якщо x дорівнює y, то..." на мову кодування можна перекласти, використовуючи `=` або оператор присвоєння. Це призводить до неочікуваних потоків керування у вашій програмі.
+
+Як зазначено у попередніх завданнях, у JavaScript оператор присвоєння (`=`) надає значення для назв змінних. І оператори `==` та `===` перевіряють їх на рівність (потрійні `===` тести для суворої рівності, вказуючи, що як значення, так і тип є однаковими).
+
+Поданий нижче код присвоює `x` значення 2, що оцінюватиметься як `true`. Майже кожне значення у JavaScript самостійно оцінюється до `true`, за винятком деяких випадків, які нам відомі як неправильні значення: `false`, `0`, `""` (пустий рядок), `NaN`, `undefined` та `null`.
+
+```js
+let x = 1;
+let y = 2;
+if (x = y) {
+
+} else {
+
+}
+```
+
+У цьому прикладі блок коду в межах оператора `if` не виконуватиметься для будь-якого значення `y`, якщо тільки `y` не буде помилковим. Блок `else`, який за нашими очікуваннями повинен тут виконуватися, насправді не буде запускатися.
+
+# --instructions--
+
+Виправіть умову таким чином, щоб програма виконувалася у правій гілці, і відповідне значення було присвоєне `result`.
+
+# --hints--
+
+Ваш код має виправити умову так, щоб відбувалася перевірка рівності замість використання оператора присвоєння.
+
+```js
+assert(result == 'Not equal!');
+```
+
+Умова має використовувати або `==`, або `===`, щоб відбувалася перевірка рівності.
+
+```js
+assert(code.match(/x\s*?===?\s*?y/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x = y) {
+ result = "Equal!";
+} else {
+ result = "Not equal!";
+}
+
+console.log(result);
+```
+
+# --solutions--
+
+```js
+let x = 7;
+let y = 9;
+let result = "to come";
+
+if(x === y) {
+ result = "Equal!";
+} else {
+ result = "Not equal!";
+}
+
+console.log(result);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md
new file mode 100644
index 00000000000..467dbfc3104
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/prevent-infinite-loops-with-a-valid-terminal-condition.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b86367417b2b2512b3d
+title: Запобігання безкінечним циклам дійсною кінцевою умовою
+challengeType: 1
+forumTopicId: 301192
+dashedName: prevent-infinite-loops-with-a-valid-terminal-condition
+---
+
+# --description--
+
+Остання тема - це безкінечний цикл, який багатьох жахає. Цикли є чудовими інструментами, коли вам необхідно, щоб ваша програма виконувала блок коду певну кількість разів, або поки умова не буде виконана, але їм також потрібна кінцева умова, яка закінчить цикл. Нескінченні цикли можуть призвести до блокування або збоїв у роботі браузера, чого кожен прагнув би уникнути.
+
+У вступі до цього розділу був приклад нескінченного циклу - у нього немає кінцевої умови для того, щоб вибратися з циклу `while` всередині `loopy()`. НЕ викликайте цю функцію!
+
+```js
+function loopy() {
+ while(true) {
+ console.log("Hello, world!");
+ }
+}
+```
+
+Завданням програми є гарантувати, що кінцева умова, яка вказує програмі на момент розірвання коду циклу, нарешті досягнута. Одна помилка може зменшити або збільшити змінну лічильника у неправильному від кінцевої умови напрямку. Інша ж може випадково скинути дані лічильника чи змінну індексу всередині самого циклу замість його збільшення чи зменшення.
+
+# --instructions--
+
+Функція `myFunc()` містить нескінченний цикл, оскільки кінцева умова `i != 4` ніколи не оцінюватиметься як `false` (та не розірве цикл) - `i` збільшуватиметься на 2 з кожним виконанням циклу і пропустить 4, оскільки `i` має бути непарним для початку запуску. Виправіть оператора порівняння у кінцевій умові так, щоб цикл виконувався лише якщо `i` менше або рівне 4.
+
+# --hints--
+
+Ваш код повинен змінити оператора порівняння у кінцевій умові (середня частина) циклу `for`.
+
+```js
+assert(code.match(/i\s*?<=\s*?4;/g).length == 1);
+```
+
+Ваш код повинен виправити оператора порівняння у кінцевій умові циклу.
+
+```js
+assert(!code.match(/i\s*?!=\s*?4;/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myFunc() {
+ for (let i = 1; i != 4; i += 2) {
+ console.log("Still going!");
+ }
+}
+```
+
+# --solutions--
+
+```js
+function myFunc() {
+ for (let i = 1; i <= 4; i += 2) {
+ console.log("Still going!");
+ }
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md
new file mode 100644
index 00000000000..e2bd53f33d3
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/understanding-the-differences-between-the-freecodecamp-and-browser-console.md
@@ -0,0 +1,65 @@
+---
+id: 587d7b83367417b2b2512b37
+title: Розуміння різниці між freeCodeCamp та консоллю браузера
+challengeType: 1
+forumTopicId: 301193
+dashedName: understanding-the-differences-between-the-freecodecamp-and-browser-console
+---
+
+# --description--
+
+Ви могли помітити, що у завдань freeCodeCamp є власна консоль. Ця консоль функціонує трохи інакше, ніж консоль браузера.
+
+Існує багато способів, які можна використовувати за допомогою `console` для виведення повідомлень. Наприклад, ось деякі з них: `log`, `warn` та `clear`. Консоль freeCodeCamp виведе лише `log` повідомлення, у той час як консоль браузера виведе всі повідомлення. У разі внесення змін до коду він автоматично запуститься та покаже системні журнали. Отже, консоль freeCodeCamp очищується щоразу, як запускається ваш код.
+
+# --instructions--
+
+Спочатку відкрийте консоль вашого браузера так, щоб бачити системні журнали. Для цього натисніть правою кнопкою миші зверху на панелі навігаційної стрічки freeCodeCamp та виберіть `inspect` на панелі інструментів більшості браузерів. Потім знайдіть вкладку `console` у вікні, що відкриється.
+
+Після цього використайте `console.log`, щоб зазначити змінну `output`. Перегляньте дві консолі, щоб побачити системний журнал. Наприкінці використайте функцію `console.clear` після вашого системного журналу, щоб очистити консоль браузера. Побачте різницю у двох консолях.
+
+# --hints--
+
+Ви повинні використати `console.log()`, щоб вивести на екран змінну `output`.
+
+```js
+assert(__helpers.removeWhiteSpace(code).match(/console\.log\(output\)/));
+```
+
+Ви повинні використати `console.clear()`, щоб очистити консоль браузера.
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/console.clear\(\)/)
+);
+```
+
+Ви повинні очистити консоль після свого системного журналу.
+
+```js
+assert(
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/console\.log\(output\)[\s\S]*console.clear\(\)/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let output = "Get this to show once in the freeCodeCamp console and not at all in the browser console";
+
+```
+
+# --solutions--
+
+```js
+let output = "Get this to show once in the freeCodeCamp console and not at all in the browser console";
+
+console.log(output);
+console.clear();
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md
new file mode 100644
index 00000000000..f9bac61075e
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-caution-when-reinitializing-variables-inside-a-loop.md
@@ -0,0 +1,97 @@
+---
+id: 587d7b86367417b2b2512b3c
+title: Будьте обережні при реініціалізації змінних всередині циклу
+challengeType: 1
+forumTopicId: 301194
+dashedName: use-caution-when-reinitializing-variables-inside-a-loop
+---
+
+# --description--
+
+Часом буває необхідно зберегти інформацію, збільшити лічильники чи перевстановити змінні всередині самого циклу. Проблема може виникнути, що змінні або повинні бути реініціалізовані, але ще не були реініціалізовані, або ж навпаки. Це особливо небезпечно, якщо ви випадково скинули змінну, яка використовується в кінцевій умові, що може спричинити появу нескінченного циклу.
+
+Виявити помилки, які можуть повторюватися в результаті скидання або невдалих спроб скинути змінну, можливо виведенням значень змінних на екран кожного повторення циклу, використовуючи функцію `console.log()`.
+
+# --instructions--
+
+Подана нижче функція повинна створити двовимірний масив із `m` рядків та `n` стовпців з нулів. На жаль, вона не має очікуваного результату, оскільки змінна `row` не реініціалізована (встановлена на порожньому масиві) у зовнішньому циклі. Виправіть код так, щоб він повертав правильний 3x2 масив з нулів, який повинен мати такий вигляд: `[[0, 0], [0, 0], [0, 0]]`.
+
+# --hints--
+
+Ваш код повинен встановити змінну `matrix` у масиві, що містить 3 рядки з 2 стовпців нулів кожен.
+
+```js
+assert(JSON.stringify(matrix) == '[[0,0],[0,0],[0,0]]');
+```
+
+Змінна `matrix` повинна мати 3 рядки.
+
+```js
+assert(matrix.length == 3);
+```
+
+Змінна `matrix` повинна мати 2 стовпці в кожному рядку.
+
+```js
+assert(
+ matrix[0].length == 2 && matrix[1].length === 2 && matrix[2].length === 2
+);
+```
+
+`zeroArray(4,3)` повинен повернути масив, який містить 4 рядки з 3 стовпців нулів кожен.
+
+```js
+assert(JSON.stringify(zeroArray(4,3)) == '[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function zeroArray(m, n) {
+ // Creates a 2-D array with m rows and n columns of zeroes
+ let newArray = [];
+ let row = [];
+ for (let i = 0; i < m; i++) {
+ // Adds the m-th row into newArray
+
+ for (let j = 0; j < n; j++) {
+ // Pushes n zeroes into the current row to create the columns
+ row.push(0);
+ }
+ // Pushes the current row, which now has n zeroes in it, to the array
+ newArray.push(row);
+ }
+ return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+
+```
+
+# --solutions--
+
+```js
+function zeroArray(m, n) {
+ // Creates a 2-D array with m rows and n columns of zeroes
+ let newArray = [];
+ for (let i = 0; i < m; i++) {
+ let row = [];
+ // Adds the m-th row into newArray
+
+ for (let j = 0; j < n; j++) {
+ // Pushes n zeroes into the current row to create the columns
+ row.push(0);
+ }
+ // Pushes the current row, which now has n zeroes in it, to the array
+ newArray.push(row);
+ }
+ return newArray;
+}
+
+let matrix = zeroArray(3, 2);
+console.log(matrix);
+
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md
new file mode 100644
index 00000000000..a5d60e58ee7
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-the-javascript-console-to-check-the-value-of-a-variable.md
@@ -0,0 +1,54 @@
+---
+id: 587d7b83367417b2b2512b33
+title: Використання консолі JavaScript для перевірки значення змінної
+challengeType: 1
+forumTopicId: 18372
+dashedName: use-the-javascript-console-to-check-the-value-of-a-variable
+---
+
+# --description--
+
+І Chrome, і Firefox мають чудові консолі, також відомі як DevTools, для налагодження роботи вашої JavaScript.
+
+Ви можете знайти інструменти розробника в меню вашого Chrome або у веб-консолі в меню Firefox. Якщо ви використовуєте інший браузер або мобільний телефон, ми наполегливо радимо вам натомість працювати з комп'ютерною версією Firefox або Chrome.
+
+Метод `console.log()`, який "виводить" вихідні дані з тих, що знаходяться між його дужками до консолі, імовірно, буде найкориснішим інструментом для налагодження програм. Розміщення його у стратегічно важливих місцях вашого коду може показати вам проміжні значення змінних. Добре мати уявлення про те, яким повинен бути результат, перш ніж розглянути, яким він є. Формування ключових моментів для розуміння стану ваших розрахунків у всьому коді допоможе скоротити кількість місць для пошуку проблеми.
+
+Ось приклад виведення на екран консолі рядка `Hello world!`:
+
+```js
+console.log('Hello world!');
+```
+
+# --instructions--
+
+Використайте метод `console.log()`, щоб вивести на екран значення змінної `a`, де це вказано в коді.
+
+# --hints--
+
+Ваш код повинен використовувати `console.log()` для перевірки значення змінної `a`.
+
+```js
+assert(code.match(/console\.log\(a\)/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let a = 5;
+let b = 1;
+a++;
+// Only change code below this line
+
+
+let sumAB = a + b;
+console.log(sumAB);
+```
+
+# --solutions--
+
+```js
+var a = 5; console.log(a);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
new file mode 100644
index 00000000000..31ad60d43a9
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/debugging/use-typeof-to-check-the-type-of-a-variable.md
@@ -0,0 +1,66 @@
+---
+id: 587d7b84367417b2b2512b34
+title: Використання typeof для перевірки типу змінної
+challengeType: 1
+forumTopicId: 18374
+dashedName: use-typeof-to-check-the-type-of-a-variable
+---
+
+# --description--
+
+Ви можете використовувати оператор `typeof` для перевірки структури даних або типу змінної. Це може бути корисним для налагодження програм у випадку, коли ви працюєте з різними типами даних. Якщо ви думаєте, що додаєте два числа, але одне з них насправді є рядком, результати можуть бути непередбачуваними. Помилки в типах даних можуть ховатися у розрахунках або ж викликах функцій. Будьте особливо обережні, отримуючи доступ та працюючи із зовнішніми даними у вигляді запису об'єктів JavaScript (JSON).
+
+Ось кілька прикладів використання оператора `typeof`:
+
+```js
+console.log(typeof "");
+console.log(typeof 0);
+console.log(typeof []);
+console.log(typeof {});
+```
+
+Консоль по порядку відображатиме рядки `string`, `number`, `object` та `object`.
+
+JavaScript розпізнає шість примітивних (незмінних) типів даних `Boolean`, `Null`, `Undefined`, `Number`, `String` та `Symbol` (новий з ES6) і один тип для змінних елементів: `Object`. Візьміть до уваги, що у JavaScript масиви технічно є типом об'єкту.
+
+# --instructions--
+
+Додайте дві команди `console.log()` для перевірки оператором `typeof` кожної з двох змінних, `seven` та `three`, у коді.
+
+# --hints--
+
+Ваш код повинен використати оператор `typeof` у двох командах `console.log()` для перевірки типів змінних.
+
+```js
+assert(code.match(/console\.log\(typeof[\( ].*\)?\)/g).length == 2);
+```
+
+Ваш код повинен використати оператор `typeof` для перевірки типу змінної `seven`.
+
+```js
+assert(code.match(/typeof[\( ]seven\)?/g));
+```
+
+Ваш код повинен використати оператор `typeof` для перевірки типу змінної `three`.
+
+```js
+assert(code.match(/typeof[\( ]three\)?/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let seven = 7;
+let three = "3";
+console.log(seven + three);
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let seven = 7;let three = "3";console.log(typeof seven);
+console.log(typeof three);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
new file mode 100644
index 00000000000..5a34d08da76
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/compare-scopes-of-the-var-and-let-keywords.md
@@ -0,0 +1,134 @@
+---
+id: 587d7b87367417b2b2512b40
+title: Порівняйте можливості ключових слів var та let
+challengeType: 1
+forumTopicId: 301195
+dashedName: compare-scopes-of-the-var-and-let-keywords
+---
+
+# --description--
+
+Якщо ви ще не знаєте про `let`, то перегляньте [це завдання](/learn/javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords).
+
+Коли ви задаєте змінну з ключовим словом `var`, вона стане глобальною або локальною, якщо буде оголошена у рамках функції.
+
+Ключове слово `let` функціонує схожим чином, але з додатковими можливостями. Коли ви задаєте змінну з ключовим словом `let` у блоці, команді чи виразі, її можливості обмежуються цим блоком, виразом чи виразом.
+
+Наприклад:
+
+```js
+var numArray = [];
+for (var i = 0; i < 3; i++) {
+ numArray.push(i);
+}
+console.log(numArray);
+console.log(i);
+```
+
+У такому разі консоль показуватиме значення `[0, 1, 2]` та `3`.
+
+Якщо ключове слово — `var`, значення `i` оголошується глобальним. Отже, коли виконується `i++`, глобальна змінна теж оновлюється. Цей код виглядає наступним чином:
+
+```js
+var numArray = [];
+var i;
+for (i = 0; i < 3; i++) {
+ numArray.push(i);
+}
+console.log(numArray);
+console.log(i);
+```
+
+У такому разі консоль показуватиме значення `[0, 1, 2]` та `3`.
+
+Така поведінка спричиняє проблеми при створенні функції та її збереженні для подальшого використання в циклі `for`, що використовує змінну `i`. Це пояснюється тим, що збережена функція завжди посилатиметься на значення оновленої глобальної змінної `i`.
+
+```js
+var printNumTwo;
+for (var i = 0; i < 3; i++) {
+ if (i === 2) {
+ printNumTwo = function() {
+ return i;
+ };
+ }
+}
+console.log(printNumTwo());
+```
+
+У такому разі консоль показуватиме значення `3`.
+
+Як бачите, `printNumTwo()` показує 3, а не 2. Це пояснюється тим, що значення для `i` оновилося, а `printNumTwo()` повертає глобальне значення `i`, а не те значення, яке `i` мало при створенні функції для циклу. Ключове слово `let` діє інакше:
+
+```js
+let printNumTwo;
+for (let i = 0; i < 3; i++) {
+ if (i === 2) {
+ printNumTwo = function() {
+ return i;
+ };
+ }
+}
+console.log(printNumTwo());
+console.log(i);
+```
+
+У такому разі консоль показуватиме значення `2`, і помилку: `i is not defined`.
+
+`i` не визначено (not defined), оскільки змінну не було оголошено в глобальному масштабі. Вона стає оголошеною лише у команді циклу `for`. `printNumTwo()` повернув правильне значення, оскільки було створено три різних змінних `i` з унікальними значеннями (0, 1, та 2) завдяки ключовому слову `let` в рамках команди циклу.
+
+# --instructions--
+
+Виправте код так, щоб `i`, оголошена в команді `if`, була окремою змінною, на відміну від `i`, оголошеної у першому рядку функції. Не використовуйте у вашому коді ключове слово `var`.
+
+Ця вправа створена для того, щоб показати відмінність між тим, як ключові слова `var` і `let` задають можливості оголошеної змінної. При програмуванні схожої функції на ту, що використовувалася у цій вправі, нерідко слід використовувати різні назви для змінних, щоб уникнути плутанини.
+
+# --hints--
+
+`var` має бути відсутнім у коді.
+
+```js
+assert(!code.match(/var/g));
+```
+
+Змінна `i`, оголошена в операторі `if`, має дорівнювати рядку `block scope`.
+
+```js
+assert(code.match(/(i\s*=\s*).*\s*.*\s*.*\1('|")block\s*scope\2/g));
+```
+
+`checkScope()` має повернути рядок `function scope`
+
+```js
+assert(checkScope() === 'function scope');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkScope() {
+ var i = 'function scope';
+ if (true) {
+ i = 'block scope';
+ console.log('Block scope i is: ', i);
+ }
+ console.log('Function scope i is: ', i);
+ return i;
+}
+```
+
+# --solutions--
+
+```js
+function checkScope() {
+ let i = 'function scope';
+ if (true) {
+ let i = 'block scope';
+ console.log('Block scope i is: ', i);
+ }
+
+ console.log('Function scope i is: ', i);
+ return i;
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md
new file mode 100644
index 00000000000..1c2dda1ccb0
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/complete-a-promise-with-resolve-and-reject.md
@@ -0,0 +1,77 @@
+---
+id: 5cdafbc32913098997531680
+title: Виконайте Promise за допомогою команд resolve та reject
+challengeType: 1
+forumTopicId: 301196
+dashedName: complete-a-promise-with-resolve-and-reject
+---
+
+# --description--
+
+Promise має три стани: `pending`, `fulfilled` та `rejected`. Promise, який ви створили у попередньому завданні, буде завжди знаходитися у стані `pending`, оскільки ви не передбачили можливості завершити Promise. Для цього використовуються параметри `resolve` і `reject`, що належать аргументу Promise. `resolve` використовується для виконання Promise, а `reject` використовується для відхилення Promise. При таких методах з'являється аргумент, як показано нижче.
+
+```js
+const myPromise = new Promise((resolve, reject) => {
+ if(condition here) {
+ resolve("Promise was fulfilled");
+ } else {
+ reject("Promise was rejected");
+ }
+});
+```
+
+Попередній приклад використовує рядки для аргументу цих функцій, але можливі й інші варіанти. Часто це може також бути об'єкт, дані якого ви використаєте для розміщення на своєму сайті чи в іншому місці.
+
+# --instructions--
+
+Запрограмуйте Promise так, щоб він самостійно обробляв виконання або відхилення. Якщо `responseFromServer` виявляється `true`, викличте метод `resolve`, щоб успішно виконати Promise. Додайте до `resolve` рядок зі значенням `We got the data`. Якщо `responseFromServer` виявляється `false`, використайте метод `reject` і додайте рядок `Data not received`.
+
+# --hints--
+
+`resolve` має викликатися за допомогою очікуваного рядка, а значення `if` має бути `true`.
+
+```js
+assert(
+ code.match(/if\s*\(\s*responseFromServer\s*\)\s*{\s*resolve\s*\(\s*('|"|`)We got the data\1\s*\)(\s*|\s*;\s*)}/g)
+);
+```
+
+`reject` має викликатися за допомогою очікуваного рядка, а значення `if` має бути `false`.
+
+```js
+assert(
+ code.match(/}\s*else\s*{\s*reject\s*\(\s*('|"|`)Data not received\1\s*\)(\s*|\s*;\s*)}/g)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer represents a response from a server
+ let responseFromServer;
+
+ if(responseFromServer) {
+ // Change this line
+ } else {
+ // Change this line
+ }
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer represents a response from a server
+ let responseFromServer;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md
new file mode 100644
index 00000000000..842cfb29650
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-a-javascript-promise.md
@@ -0,0 +1,55 @@
+---
+id: 5cdafbb0291309899753167f
+title: Створіть Promise у JavaScript
+challengeType: 1
+forumTopicId: 301197
+dashedName: create-a-javascript-promise
+---
+
+# --description--
+
+У JavaScript Promise (з англ. «обіцянка») має пряме значення: цей термін використовується для того, щоб «пообіцяти» щось зробити, зазвичай асинхронно. Коли завдання звершується, ви або виконуєте Promise, або відхиляєте його. `Promise` - це функція конструктора, тож необхідно використати ключове слово `new`, щоб створити новий Promise. Для цього потрібні функція, як його аргумент, з двома параметрами: `resolve` та `reject`. Такі методи використовуються для визначення результату Promise. Синтаксис виглядає наступним чином:
+
+```js
+const myPromise = new Promise((resolve, reject) => {
+
+});
+```
+
+# --instructions--
+
+Створіть новий Promise під назвою `makeServerRequest`. У функції перейдіть до параметрів конструктора `resolve` та `reject`.
+
+# --hints--
+
+Призначте Promise до оголошеної змінної під назвою `makeServerRequest`.
+
+```js
+assert(makeServerRequest instanceof Promise);
+```
+
+Ваш Promise має отримати функцію з параметрами `resolve` та `reject`.
+
+```js
+assert(
+ code.match(
+ /Promise\(\s*(function\s*\(\s*resolve\s*,\s*reject\s*\)\s*{|\(\s*resolve\s*,\s*reject\s*\)\s*=>\s*{)[^}]*}/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+
+});
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md
new file mode 100644
index 00000000000..839a6254463
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-a-module-script.md
@@ -0,0 +1,73 @@
+---
+id: 5cddbfd622f1a59093ec611d
+title: Створіть модульний скрипт
+challengeType: 6
+forumTopicId: 301198
+dashedName: create-a-module-script
+---
+
+# --description--
+
+Спочатку мова JavaScript відігравала незначну роль на веб-сторінках HTML, створених по-іншому. Сьогодні вона має величезне значення. Деякі сайти навіть створюються майже повністю за допомогою JavaScript. Для того, щоб мова JavaScript була більш модульною, точною і зручною у користуванні, ES6 створив новий спосіб для доступної передачі коду між файлами JavaScript. Таким чином, ви можете експортувати частини файлу і використати їх в більше ніж одному іншому файлі, а також імпортувати потрібні вам уривки. Щоб скористатися таким функціоналом, необхідно створити скрипт у вашому HTML-документі з `module` `type`. Наприклад:
+
+```html
+
+```
+
+Скрипт, що використовує тип `module`, відтепер може використовувати функції `import` і `export`, про які ви дізнаєтеся більше у наступних завданнях.
+
+# --instructions--
+
+Додайте скрипт до HTML-документа типу `module` та зробіть його вихідним файлом `index.js`
+
+# --hints--
+
+Ви маєте створити тег `script`.
+
+```js
+assert(code.match(/<\s*script[^>]*>\s*<\/\s*script\s*>/g));
+```
+
+Ваш тег `script` повинен мати атрибут `type` зі значенням `module`.
+
+```js
+assert(
+ code.match(
+ /<\s*script\s+[^t]*type\s*=\s*('|")module\1[^>]*>\s*<\/\s*script\s*>/g
+ )
+);
+```
+
+Ваш тег `script` повинен мати `index.js` `src`.
+
+```js
+assert(
+ code.match(
+ /<\s*script\s+[^s]*src\s*=\s*('|")index\.js\1[^>]*>\s*<\/\s*script\s*>/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+
+
+
+
+
+
+```
+
+# --solutions--
+
+```html
+
+
+
+
+
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md
new file mode 100644
index 00000000000..1f621d3e761
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-an-export-fallback-with-export-default.md
@@ -0,0 +1,63 @@
+---
+id: 587d7b8c367417b2b2512b58
+title: Створіть резервне значення з експортом за замовчуванням
+challengeType: 1
+forumTopicId: 301199
+dashedName: create-an-export-fallback-with-export-default
+---
+
+# --description--
+
+В уроці про `export` ви дізналися про синтаксис під назвою named export. Це дозволило вам створювати чисельні функції та змінні, які можуть використовуватися і в інших файлах.
+
+Існує інший важливий синтаксис `export`, який називається export default. Як правило, такий синтаксис використовується, якщо з файлу експортується лише одне значення. Він також слугує для створення резервного значення для файлу або модуля.
+
+Нижче наведено приклади, де використовується `export default`:
+
+```js
+export default function add(x, y) {
+ return x + y;
+}
+
+export default function(x, y) {
+ return x + y;
+}
+```
+
+Перший приклад - названа функція, а другий - анонімна функція.
+
+Оскільки `export default` використовується для оголошення резервного значення для модуля або файлу, лише одне значення може бути експортоване за замовчуванням у кожному модулі або файлі. Крім того, використання `export default` з `var`, `let` або `const` є неможливим
+
+# --instructions--
+
+Наступна функція має бути резервним значенням для модуля. Для цього необхідно додати відповідний код.
+
+# --hints--
+
+Ваш код має використовувати резервне значення `export`.
+
+```js
+assert(
+ code.match(
+ /export\s+default\s+function(\s+subtract\s*|\s*)\(\s*x,\s*y\s*\)\s*{/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function subtract(x, y) {
+ return x - y;
+}
+```
+
+# --solutions--
+
+```js
+export default function subtract(x, y) {
+ return x - y;
+}
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md
new file mode 100644
index 00000000000..ea4ec1d4e41
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/create-strings-using-template-literals.md
@@ -0,0 +1,116 @@
+---
+id: 587d7b8a367417b2b2512b4e
+title: Створіть рядки за допомогою шаблонних літералів
+challengeType: 1
+forumTopicId: 301200
+dashedName: create-strings-using-template-literals
+---
+
+# --description--
+
+Нова особливість ES6 полягає у template literal. Вона означає особливий тип рядка, що полегшує процес створення складних рядків.
+
+Шаблонні літерали дозволяють нам створювати багатолінійні рядки та використовувати можливості інтерполяції для створення рядків.
+
+Розгляньмо наступний код:
+
+```js
+const person = {
+ name: "Zodiac Hasbro",
+ age: 56
+};
+
+const greeting = `Hello, my name is ${person.name}!
+I am ${person.age} years old.`;
+
+console.log(greeting);
+```
+
+Консоль показуватиме рядки `Hello, my name is Zodiac Hasbro!` та `I am 56 years old.`.
+
+Тут відбувається багато процесів. По-перше, у прикладі вживаються зворотні лапки (`` ` ``), а не одинарні чи подвійні (`'` чи `"`), щоб обрамити рядок. По-друге, зверніть увагу, що рядок залишається багатолінійним як у коді, так і в кінцевому вигляді. Завдяки цьому, `\n` вставляється у самі рядки. Наведений вище синтаксис `${variable}` є заповнювачем місця (placeholder). Це означає, що більше не потрібно використовувати конкатенацію з оператором `+`. Для додання змінних до рядків варто видалити змінну в шаблонному рядку та розмістити її у конструкцію `${` і `}`. Інші вирази також можуть додаватися до літералу у рядку схожим чином, наприклад `${a + b}`. Такий новий спосіб створення рядків надає більше можливостей створювати функціональні рядки.
+
+# --instructions--
+
+Використовуйте синтаксис шаблонних літералів зі зворотними лапками для створення масиву елемента списку - рядків (`li`). Текст кожного елемента списку має бути одним з елементів масиву зі значенням `failure` на об'єкті `result` та мати атрибут `class` зі значенням `text-warning`. Функція `makeList` повинна повернути масив елементів списку у рядках.
+
+Завдяки методу, що використовує ітератор (будь-який цикл), ми можемо отримати бажаний результат (наведений нижче).
+
+```js
+[
+ 'no-var',
+ 'var-on-top',
+ 'linebreak'
+]
+```
+
+# --hints--
+
+`failuresList` має бути масивом, що містить повідомлення `result failure`.
+
+```js
+assert(
+ typeof makeList(result.failure) === 'object' && failuresList.length === 3
+);
+```
+
+`failuresList` має дорівнювати вказаному результату.
+
+```js
+assert(
+ makeList(result.failure).every(
+ (v, i) =>
+ v === `${result.failure[i]}` ||
+ v === `${result.failure[i]}`
+ )
+);
+```
+
+Варто також використовувати шаблонні рядки та інтерполяцію виразу.
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/(`.*\${.*}.*`)/));
+```
+
+Варто використовувати ітератор.
+
+```js
+(getUserInput) =>
+ assert(getUserInput('index').match(/for|map|reduce|forEach|while/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const result = {
+ success: ["max-length", "no-amd", "prefer-arrow-functions"],
+ failure: ["no-var", "var-on-top", "linebreak"],
+ skipped: ["no-extra-semi", "no-dup-keys"]
+};
+function makeList(arr) {
+ // Only change code below this line
+ const failureItems = [];
+ // Only change code above this line
+
+ return failureItems;
+}
+
+const failuresList = makeList(result.failure);
+```
+
+# --solutions--
+
+```js
+const result = {
+ success: ["max-length", "no-amd", "prefer-arrow-functions"],
+ failure: ["no-var", "var-on-top", "linebreak"],
+ skipped: ["no-extra-semi", "no-dup-keys"]
+};
+function makeList(arr) {
+ return arr.map(val => `${val}`);
+}
+
+const failuresList = makeList(result.failure);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md
new file mode 100644
index 00000000000..dd07f157e55
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/handle-a-fulfilled-promise-with-then.md
@@ -0,0 +1,92 @@
+---
+id: 5cdafbd72913098997531681
+title: Вирішіть проблему Promise у стані Fulfilled за допомогою then
+challengeType: 1
+forumTopicId: 301203
+dashedName: handle-a-fulfilled-promise-with-then
+---
+
+# --description--
+
+Promises надзвичайно корисні, коли у вашому коді відбувається процес, що займає невизначений період часу (тобто асинхронний процес), наприклад, запит до сервера. Створення запиту до сервера займає певний час, а після його завершення, зазвичай, передбачаються подальші дії з відповіддю сервера. Цього можна досягти за допомогою методу `then`. Метод `then` виконується одразу після того, як ваш Promise входить у стан Fulfilled `resolve`. Наприклад:
+
+```js
+myPromise.then(result => {
+
+});
+```
+
+`result` отримується за допомогою аргументу та методу `resolve`.
+
+# --instructions--
+
+Додайте до вашого Promise метод `then`. Використовуйте `result` як параметр для функції зворотного виклику та зазначте `result` у консолі.
+
+# --hints--
+
+Слід викликати метод `then` для Promise.
+
+```js
+assert(
+ __helpers.removeWhiteSpace(code).match(/(makeServerRequest|\))\.then\(/g)
+);
+```
+
+Ваш метод `then` повинен мати функцію зворотного виклику з `result` у якості параметра.
+
+```js
+assert(resultIsParameter);
+```
+
+Ви маєте зазначити `result` у консолі.
+
+```js
+assert(
+ resultIsParameter &&
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\.then\(.*?result.*?console.log\(result\).*?\)/)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const resultIsParameter = /\.then\((function\(result\){|result|\(result\)=>)/.test(__helpers.removeWhiteSpace(code));
+```
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to true to represent a successful response from a server
+ let responseFromServer = true;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to true to represent a successful response from a server
+ let responseFromServer = true;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md
new file mode 100644
index 00000000000..f87104b4736
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/handle-a-rejected-promise-with-catch.md
@@ -0,0 +1,100 @@
+---
+id: 5cdafbe72913098997531682
+title: Обробка винятків відхиленої Promise
+challengeType: 1
+forumTopicId: 301204
+dashedName: handle-a-rejected-promise-with-catch
+---
+
+# --description--
+
+`catch` - це метод, який використовується коли ваша Promise була відхилена. Це буде виконано одразу після запуску алгоритму `reject`. Ось синтаксис:
+
+```js
+myPromise.catch(error => {
+
+});
+```
+
+`error` передана в метод `reject`.
+
+# --instructions--
+
+Додайте до вашого Promise метод `catch`. Використовуйте `error` у якості параметра для функції зворотного виклику та зазначте `error` у консолі.
+
+# --hints--
+
+Слід використати метод `catch` для Promise.
+
+```js
+assert(
+ __helpers.removeWhiteSpace(code).match(/(makeServerRequest|\))\.catch\(/g)
+);
+```
+
+Ваш метод `catch` повинен мати функцію зворотнього виклику з `error` у якості параметра.
+
+```js
+assert(errorIsParameter);
+```
+
+Ви маєте зазначити `error` у консолі.
+
+```js
+assert(
+ errorIsParameter &&
+ __helpers
+ .removeWhiteSpace(code)
+ .match(/\.catch\(.*?error.*?console.log\(error\).*?\)/)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+const errorIsParameter = /\.catch\((function\(error\){|error|\(error\)=>)/.test(__helpers.removeWhiteSpace(code));
+```
+
+## --seed-contents--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to false to represent an unsuccessful response from a server
+ let responseFromServer = false;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+```
+
+# --solutions--
+
+```js
+const makeServerRequest = new Promise((resolve, reject) => {
+ // responseFromServer is set to false to represent an unsuccessful response from a server
+ let responseFromServer = false;
+
+ if(responseFromServer) {
+ resolve("We got the data");
+ } else {
+ reject("Data not received");
+ }
+});
+
+makeServerRequest.then(result => {
+ console.log(result);
+});
+
+makeServerRequest.catch(error => {
+ console.log(error);
+});
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md
new file mode 100644
index 00000000000..1ab6d3efcd9
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/import-a-default-export.md
@@ -0,0 +1,48 @@
+---
+id: 587d7b8d367417b2b2512b59
+title: Імпорт модуля Default Export за змовчуванням
+challengeType: 1
+forumTopicId: 301205
+dashedName: import-a-default-export
+---
+
+# --description--
+
+У вашому останньому завданні ви дізнались про `xportdefault` та його використання. Для імпорту default export необхідно використовувати інший синтаксис `import`. У наступному прикладі `add` є експорт за змовчуванням файлу `math_functions.js`. Ось як потрібно імпортувати:
+
+```js
+import add from "./math_functions.js";
+```
+
+Є одна ключова відмінність синтаксису. Імпортоване значення `add` не обрамлене фігурними дужками (`{}`). `add` це назва змінної для будь-якого експорту за змовчуванням в файл `math_functions.js`. Файл за змовчуванням можна називати в довільному порядку.
+
+# --instructions--
+
+У наступному коді імпортуйте експорт за замовчуванням з файлу `math_functions.js`, знайдений в тій же папці, що і цей файл. Назвіть імпорт `subtract`.
+
+# --hints--
+
+Належним чином імпортуйте `subtract` з `math_functions.js`.
+
+```js
+assert(code.match(/import\s+subtract\s+from\s+('|")\.\/math_functions\.js\1/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+subtract(7,4);
+```
+
+# --solutions--
+
+```js
+import subtract from "./math_functions.js";
+
+subtract(7,4);
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
new file mode 100644
index 00000000000..6f6ae57d83e
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/mutate-an-array-declared-with-const.md
@@ -0,0 +1,91 @@
+---
+id: 587d7b87367417b2b2512b42
+title: Видозмінюйте наданий масив за допомогою змінної
+challengeType: 1
+forumTopicId: 301206
+dashedName: mutate-an-array-declared-with-const
+---
+
+# --description--
+
+Якщо ви ще не знаєте про `const`, то перегляньте [це завдання](/learn/javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword).
+
+Є багато значень змінної `const` у сучасній JavaScript.
+
+Деякі розробники надають перевагу привласненню усіх змінних за допомогою `const`, доки вони не дізнаються про можливу необхідність перепризначення змінної. Тоді вони використовують `let`.
+
+Проте варто розуміти, що об'єкти (включаючи масиви та функції), призначенні змінній за допомогою `const`, все ще можна змінювати. Правильне використання `const` запобігає зміненню ідентифікатора змінної.
+
+```js
+const s = [5, 6, 7];
+s = [1, 2, 3];
+s[2] = 45;
+console.log(s);
+```
+
+`s = [1, 2, 3]` призведе до помилки. Виклик `console.log` відображає `[5, 6, 45]`.
+
+Як ви помітили, можна змінювати об'єкт `[5, 6, 7]`. Змінна `s` все ще вказуватиме на змінений масив `[5, 6, 45]s` є незмінними, бо було використано `const`. Ви не можете використовувати ідентифікатор змінної `s`, щоб вказувати на інший масив оператору призначення.
+
+# --instructions--
+
+Масив оголошується як `const s = [5, 7, 2]`. Змініть масив на `[2, 5, 7]` використовуючи різні призначення елементів.
+
+# --hints--
+
+Вам не слід замінювати ключове слово `const`.
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const/g));
+```
+
+`s` має бути постійно змінною (використовуйте `const`).
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const\s+s/g));
+```
+
+Не слід змінювати початковий масив.
+
+```js
+(getUserInput) =>
+ assert(
+ getUserInput('index').match(
+ /const\s+s\s*=\s*\[\s*5\s*,\s*7\s*,\s*2\s*\]\s*;?/g
+ )
+ );
+```
+
+`s` повинен дорівнювати `[2, 5, 7]`.
+
+```js
+assert.deepEqual(s, [2, 5, 7]);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const s = [5, 7, 2];
+function editInPlace() {
+ // Only change code below this line
+
+ // Using s = [2, 5, 7] would be invalid
+
+ // Only change code above this line
+}
+editInPlace();
+```
+
+# --solutions--
+
+```js
+const s = [5, 7, 2];
+function editInPlace() {
+ s[0] = 2;
+ s[1] = 5;
+ s[2] = 7;
+}
+editInPlace();
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md
new file mode 100644
index 00000000000..cb4fd3a9734
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/prevent-object-mutation.md
@@ -0,0 +1,104 @@
+---
+id: 598f48a36c8c40764b4e52b3
+title: Запобігання мутаціям об'єкта
+challengeType: 1
+forumTopicId: 301207
+dashedName: prevent-object-mutation
+---
+
+# --description--
+
+З попереднього завдання бачимо, що `const` насправді не захищає ваші дані від змін. Щоб ваші дані не змінилися, JavaScript надає функцію `Object.freeze` для запобігання мутації даних.
+
+Будь -яка спроба змінити об'єкт буде відхилена, з помилкою, якщо тег працює в строгому режимі.
+
+```js
+let obj = {
+ name:"FreeCodeCamp",
+ review:"Awesome"
+};
+Object.freeze(obj);
+obj.review = "bad";
+obj.newProp = "Test";
+console.log(obj);
+```
+
+The `obj.review` and `obj.newProp` призначення призведе до помилок, тому що наш редактор за замовчуванням працює в строгому режимі,і консоль покаже значення `{ name: "FreeCodeCamp", review: "Awesome" }`.
+
+# --instructions--
+
+У цьому завданні вам доведеться використовувати `Object.freeze` для запобігання зміни математичних констант. Вам необхідно заморозити об'єкт `MATH_CONSTANTS` так, щоб ніхто не зміг змінити значення `PI`, додати або видалити властивості.
+
+# --hints--
+
+Вам не слід замінювати ключове слово `const`.
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const/g));
+```
+
+`MATH_CONSTANTS` має бути постійною змінною (використовуйте `const`).
+
+```js
+(getUserInput) =>
+ assert(getUserInput('index').match(/const\s+MATH_CONSTANTS/g));
+```
+
+Вам не слід змінювати початкове значення `MATH_CONSTANTS`.
+
+```js
+(getUserInput) =>
+ assert(
+ getUserInput('index').match(
+ /const\s+MATH_CONSTANTS\s+=\s+{\s+PI:\s+3.14\s+};/g
+ )
+ );
+```
+
+`PI` має дорівнювати `3.14`.
+
+```js
+assert(PI === 3.14);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function freezeObj() {
+ const MATH_CONSTANTS = {
+ PI: 3.14
+ };
+ // Only change code below this line
+
+
+ // Only change code above this line
+ try {
+ MATH_CONSTANTS.PI = 99;
+ } catch(ex) {
+ console.log(ex);
+ }
+ return MATH_CONSTANTS.PI;
+}
+const PI = freezeObj();
+```
+
+# --solutions--
+
+```js
+function freezeObj() {
+ const MATH_CONSTANTS = {
+ PI: 3.14
+ };
+ Object.freeze(MATH_CONSTANTS);
+
+ try {
+ MATH_CONSTANTS.PI = 99;
+ } catch(ex) {
+ console.log(ex);
+ }
+ return MATH_CONSTANTS.PI;
+}
+const PI = freezeObj();
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md
new file mode 100644
index 00000000000..ffa7bea451e
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/reuse-javascript-code-using-import.md
@@ -0,0 +1,70 @@
+---
+id: 587d7b8c367417b2b2512b55
+title: Повторне використання коду JavaScript за допомогою імпорту
+challengeType: 1
+forumTopicId: 301208
+dashedName: reuse-javascript-code-using-import
+---
+
+# --description--
+
+`import` дозволяє вибрати, які частини файлу або модуля завантажувати. В попередньому уроці, приклади експортуються `add` з `math_functions.js` файлу. Ось як ви можете імпортувати його та використовувати в іншому файлі:
+
+```js
+import { add } from './math_functions.js';
+```
+
+`import` знайде `add` у `math_functions.js`, і імпортує саме цю функцію для використання, а решту ігнорує. `./` повідомляє про імпорт для пошуку файлу `math_functions.js` у тій же папці, що і поточний файл. При використанні імпорту таким чином необхідний відносний шлях до файлу (`./`) та розширення файлу (`.js`).
+
+Ви можете імпортувати кілька елементів з файлу, додавши їх у інструкцію `import` так:
+
+```js
+import { add, subtract } from './math_functions.js';
+```
+
+# --instructions--
+
+Додайте відповідну інструкцію `import`, яка дозволить поточному файлу використовувати функції `uppercaseString` та `lowercaseString`, які ви експортували в попередньому уроці. Ці функції знаходяться у файлі під назвою `string_functions.js`, які знаходиться і тій самій папці, що і поточний файл.
+
+# --hints--
+
+Варто здійснити імпорт належним чином `uppercaseString`.
+
+```js
+assert(
+ code.match(
+ /import\s*{\s*(uppercaseString[^}]*|[^,]*,\s*uppercaseString\s*)}\s+from\s+('|")\.\/string_functions\.js\2/g
+ )
+);
+```
+
+Потрібно імпортувати `lowercaseString`належним чином.
+
+```js
+assert(
+ code.match(
+ /import\s*{\s*(lowercaseString[^}]*|[^,]*,\s*lowercaseString\s*)}\s+from\s+('|")\.\/string_functions\.js\2/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+uppercaseString("hello");
+lowercaseString("WORLD!");
+```
+
+# --solutions--
+
+```js
+import { uppercaseString, lowercaseString } from './string_functions.js';
+
+uppercaseString("hello");
+lowercaseString("WORLD!");
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md
new file mode 100644
index 00000000000..bdca78dfe44
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/set-default-parameters-for-your-functions.md
@@ -0,0 +1,64 @@
+---
+id: 587d7b88367417b2b2512b46
+title: Виставлення параметрів за замовчуванням для ваших функцій
+challengeType: 1
+forumTopicId: 301209
+dashedName: set-default-parameters-for-your-functions
+---
+
+# --description--
+
+Для допомоги у створенні більш гнучких функцій, ES6 пропонує default parameters для функцій.
+
+Погляньте на цей код:
+
+```js
+const greeting = (name = "Anonymous") => "Hello " + name;
+
+console.log(greeting("John"));
+console.log(greeting());
+```
+
+Консоль буде відображати рядки `Hello John` та `Hello Anonymous`.
+
+Параметр за замовчуванням спрацьовує, коли аргумент не вказано (не визначено). Як можна побачити у прикладі вище, параметр `name` отримає за замовчуванням значення `Anonymous`, якщо ви не вказали значення цього параметру. Ви можете додати значення за замовчуванням будь-якій кількості параметрів.
+
+# --instructions--
+
+Модифікуйте функцію `increment`, додавши параметри за замовчуванням, щоб одиниця була додана до `number`, якщо `value` не вказано.
+
+# --hints--
+
+Результатом `increment(5, 2)` повинен бути `7`.
+
+```js
+assert(increment(5, 2) === 7);
+```
+
+Результатом `increment(5)` повинен бути `6`.
+
+```js
+assert(increment(5) === 6);
+```
+
+Значення параметру за замовчуванням `1` слід використовувати для `value`.
+
+```js
+assert(code.match(/value\s*=\s*1/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const increment = (number, value) => number + value;
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const increment = (number, value = 1) => number + value;
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md
new file mode 100644
index 00000000000..b0dc6daadcb
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use--to-import-everything-from-a-file.md
@@ -0,0 +1,60 @@
+---
+id: 587d7b8c367417b2b2512b57
+title: Використання * для імпорту всієї інформації з файлу
+challengeType: 1
+forumTopicId: 301210
+dashedName: use--to-import-everything-from-a-file
+---
+
+# --description--
+
+Припустимо, у вас є файл і ви хочете імпортувати весь його вміст у поточний файл. Це можна зробити за допомогою `import * as` синтаксису. Ось приклад, де вміст файлу з назвою `math_functions.js` імпортується до файлу в тому ж каталозі:
+
+```js
+import * as myMathModule from "./math_functions.js";
+```
+
+Наведена вище команда `import` створить об’єкт під назвою `myMathModule`. Це змінна назва, ви можете обрати власну. Об'єкт буде містити всю експортовану інформацію з `math_functions.js`, тому ви зможете отримати доступ як до функцій, так і до інших властивостей об'єкта. Ось як ви можете використовувати функції `add` і `subtract`, які були імпортовані:
+
+```js
+myMathModule.add(2,3);
+myMathModule.subtract(5,3);
+```
+
+# --instructions--
+
+Для коду у цьому файлі необхідний вміст файлу: `string_functions.js`, який є в тому ж каталозі, що і поточний файл. Використовуйте синтаксис `import * as`, щоб імпортувати всі файли до об'єкта під назвою `stringFunctions`.
+
+# --hints--
+
+У вашому коді повинен правильно використовуватись синтаксис `import * as`.
+
+```js
+assert(
+ code.match(
+ /import\s*\*\s*as\s+stringFunctions\s+from\s*('|")\.\/string_functions\.js\1/g
+ )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+// Only change code above this line
+
+stringFunctions.uppercaseString("hello");
+stringFunctions.lowercaseString("WORLD!");
+```
+
+# --solutions--
+
+```js
+import * as stringFunctions from "./string_functions.js";
+
+// add code above this line
+stringFunctions.uppercaseString("hello");
+stringFunctions.lowercaseString("WORLD!");
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md
new file mode 100644
index 00000000000..ead154d77c6
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-arrow-functions-to-write-concise-anonymous-functions.md
@@ -0,0 +1,91 @@
+---
+id: 587d7b87367417b2b2512b43
+title: Використовуйте функцію Arrow для опису анонімної функції
+challengeType: 1
+forumTopicId: 301211
+dashedName: use-arrow-functions-to-write-concise-anonymous-functions
+---
+
+# --description--
+
+У JavaScript, нам часто не потрібно називати функцію, особливо при передачі функції в якості аргументу іншої функції. Натомість створюються вбудовані функції. Їх не потрібно називати, бо вони більш ніде не використовуються.
+
+Щоб досягнути цього, використовується наступний синтаксис:
+
+```js
+const myFunc = function() {
+ const myVar = "value";
+ return myVar;
+}
+```
+
+ES6 надає нам синтаксичні можливості, щоб не використовувати анонімних функцій таким чином. Саме тому варто використовувати **синтаксичну функцію arrow**:
+
+```js
+const myFunc = () => {
+ const myVar = "value";
+ return myVar;
+}
+```
+
+Коли відсутнє тіло функції, а є лише повернене значення, то синтаксична функція arrow дозволяє опустити ключове слово `return`, а також дужки, що стосуються коду. Це допомагає спростити невелику функцію в однорядковий вираз:
+
+```js
+const myFunc = () => "value";
+```
+
+Цей код все це поверне рядок `value` за змовчуванням.
+
+# --instructions--
+
+Перепишіть функцію, призначеній змінній `magic`, що перетворюється на`new Date()` використовуючи синтаксичну функцію arrow. Також переконайтесь, що ще нічого не визначено за допомогою ключового слова `var`.
+
+# --hints--
+
+Вам слід замінити ключове слово `var`.
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/var/g));
+```
+
+`magic` має бути постійною змінною (використовуйте `const`).
+
+```js
+(getUserInput) => assert(getUserInput('index').match(/const\s+magic/g));
+```
+
+`magic` має бути `function`.
+
+```js
+assert(typeof magic === 'function');
+```
+
+`magic()` повинна повернути правильну дату.
+
+```js
+assert(magic().setHours(0, 0, 0, 0) === new Date().setHours(0, 0, 0, 0));
+```
+
+Не використовуйте ключове слово `function`.
+
+```js
+(getUserInput) => assert(!getUserInput('index').match(/function/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var magic = function() {
+ return new Date();
+};
+```
+
+# --solutions--
+
+```js
+const magic = () => {
+ return new Date();
+};
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md
new file mode 100644
index 00000000000..7b22883c605
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-class-syntax-to-define-a-constructor-function.md
@@ -0,0 +1,100 @@
+---
+id: 587d7b8b367417b2b2512b53
+title: Використовуйте клас синтаксису для визначення функції Constructor
+challengeType: 1
+forumTopicId: 301212
+dashedName: use-class-syntax-to-define-a-constructor-function
+---
+
+# --description--
+
+ES6 забезпечує новий синтаксис для створення об'єктів, використовуючи ключове слово class.
+
+Варто зазначити, що синтаксис `class` є просто синтаксисом, а не повноцінною реалізацією об'єктно-орієнтованої парадигми, на відміну від таких мов як Java, Python, Ruby, і т.д.
+
+В ES5 зазвичай визначається функція `constructor` та використовується ключове слово `new` для створення об'єкта.
+
+```js
+var SpaceShuttle = function(targetPlanet){
+ this.targetPlanet = targetPlanet;
+}
+var zeus = new SpaceShuttle('Jupiter');
+```
+
+Синтаксис `class` просто замінює створення функції `constructor`:
+
+```js
+class SpaceShuttle {
+ constructor(targetPlanet) {
+ this.targetPlanet = targetPlanet;
+ }
+}
+const zeus = new SpaceShuttle('Jupiter');
+```
+
+Варто зазначити, що ключове слово `class` оголошує нову функцію, до якої додається конструктор. Конструктор викликається, коли ключове слово `new` використовується для створення нового об'єкту.
+
+**Примітка:** UpperCamelCase слід використовувати в конвенції для назв класів ES6, як і в `SpaceShuttle` використаного вище.
+
+Метод `constructor` це спеціальний метод для створення та ініціалізації об'єкта, створений за допомогою класу. Ви можете дізнатись про це більше у розділі "Об"єктно-орієнтоване програмування" JavaScript алгоритми та структура даних.
+
+# --instructions--
+
+Використайте ключове слово `class` та напишіть `constructor` для створення класу `Vegetable`.
+
+Клас `Vegetable` дозволяє створити об'єкт vegetable з параметром `name`, що опускає `constructor`.
+
+# --hints--
+
+`Vegetable` має бути `class` визначений методом `constructor`.
+
+```js
+assert(
+ typeof Vegetable === 'function' && typeof Vegetable.constructor === 'function'
+);
+```
+
+Використовуйте ключове слово `class`.
+
+```js
+assert(code.match(/class/g));
+```
+
+`Vegetable` має бути інстальовано.
+
+```js
+assert(() => {
+ const a = new Vegetable('apple');
+ return typeof a === 'object';
+});
+```
+
+`carrot.name` повинен повертатись як `carrot`.
+
+```js
+assert(carrot.name == 'carrot');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+
+// Only change code above this line
+
+const carrot = new Vegetable('carrot');
+console.log(carrot.name); // Should display 'carrot'
+```
+
+# --solutions--
+
+```js
+class Vegetable {
+ constructor(name) {
+ this.name = name;
+ }
+}
+const carrot = new Vegetable('carrot');
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md
new file mode 100644
index 00000000000..12f9b3af654
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-arrays.md
@@ -0,0 +1,71 @@
+---
+id: 587d7b89367417b2b2512b4b
+title: Використовуйте деструктивне привласнення для визначення змінних із масивів
+challengeType: 1
+forumTopicId: 301213
+dashedName: use-destructuring-assignment-to-assign-variables-from-arrays
+---
+
+# --description--
+
+ES6 створює деструктивні масиви так само легко, як і деструктивні об'єкти.
+
+Однією з ключових відмінностей між спред оператором та деструктивним масивом є те, що спред оператор розпаковує весь вміст масиву в список, розділений комою. Отже, ви не можете вибрати, які елементи ви бажаєте призначити змінним.
+
+Деструкція масиву дозволяє нам зробити це:
+
+```js
+const [a, b] = [1, 2, 3, 4, 5, 6];
+console.log(a, b);
+```
+
+В консолі відображатимуться значення `a` та `b` як `1, 2`.
+
+Змінна `a` призначає перше значення масиву, а `b` присвоюється друге значення масиву. Також ми можемо отримати доступ до значення у масиві з деструкцією за допомогою коми для досягнення бажаного індексу:
+
+```js
+const [a, b,,, c] = [1, 2, 3, 4, 5, 6];
+console.log(a, b, c);
+```
+
+В консолі відображатимуться значення `a`, `b`, та `c` як `1, 2, 5`.
+
+# --instructions--
+
+Використайте привласнення для заміни значень `a` and `b`, так, що `a` отримує значення, збережене в `b`, і `b` отримує значення, збережене в `a`.
+
+# --hints--
+
+Значення `a` має бути `6`, після перегортання.
+
+```js
+assert(a === 6);
+```
+
+Значення `b` має бути `8`, після перегортання.
+
+```js
+assert(b === 8);
+```
+
+Ви повинні використовувати деструктивний масив, щоб замінити `a` та `b`.
+
+```js
+assert(/\[\s*(\w)\s*,\s*(\w)\s*\]\s*=\s*\[\s*\2\s*,\s*\1\s*\]/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let a = 8, b = 6;
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+let a = 8, b = 6;
+[a, b] = [b, a];
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md
new file mode 100644
index 00000000000..6c27145f5e4
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-nested-objects.md
@@ -0,0 +1,106 @@
+---
+id: 587d7b89367417b2b2512b4a
+title: Використовуйте деструктивне привласнення для визначення змінних із масивів
+challengeType: 1
+forumTopicId: 301214
+dashedName: use-destructuring-assignment-to-assign-variables-from-nested-objects
+---
+
+# --description--
+
+Слідуйте тим самим принципам, що і у попередніх 2 уроках, які були присвячені визначенню змінних із масивів.
+
+Використовуйте змінну схожу до попередніх масивів:
+
+```js
+const user = {
+ johnDoe: {
+ age: 34,
+ email: 'johnDoe@freeCodeCamp.com'
+ }
+};
+```
+
+Розглянемо приклад, як отримати значення властивостей об'єкта та призначити їх змінним із таким самим ім'ям:
+
+```js
+const { johnDoe: { age, email }} = user;
+```
+
+Приклад того, як ви можете призначити значення з різними іменами:
+
+```js
+const { johnDoe: { age: userAge, email: userEmail }} = user;
+```
+
+# --instructions--
+
+Замініть два визначення еквівалентами з деструктивного привласнення. Ви все ще призначаєте змінним `lowToday` та `highToday` значення `today.low` та `today.high` з об'єкту `LOCAL_FORECAST`.
+
+# --hints--
+
+Видаліть призначення синтаксису ES5.
+
+```js
+assert(
+ !code.match(/lowToday = LOCAL_FORECAST\.today\.low/g) &&
+ !code.match(/highToday = LOCAL_FORECAST\.today.high/g)
+);
+```
+
+Використовуйте деструкцію, щоб створити змінну `lowToday`.
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*today\s*:\s*{\s*(low\s*:\s*lowToday[^}]*|[^,]*,\s*low\s*:\s*lowToday\s*)}\s*}\s*=\s*LOCAL_FORECAST(;|\s+|\/\/)/g
+ )
+);
+```
+
+Використовуйте деструкцію, щоб створити змінну `highToday`.
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*today\s*:\s*{\s*(high\s*:\s*highToday[^}]*|[^,]*,\s*high\s*:\s*highToday\s*)}\s*}\s*=\s*LOCAL_FORECAST(;|\s+|\/\/)/g
+ )
+);
+```
+
+`lowToday` повинна дорівнювати `64` та `highToday77`.
+
+```js
+assert(lowToday === 64 && highToday === 77);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const LOCAL_FORECAST = {
+ yesterday: { low: 61, high: 75 },
+ today: { low: 64, high: 77 },
+ tomorrow: { low: 68, high: 80 }
+};
+
+// Only change code below this line
+
+const lowToday = LOCAL_FORECAST.today.low;
+const highToday = LOCAL_FORECAST.today.high;
+
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const LOCAL_FORECAST = {
+ yesterday: { low: 61, high: 75 },
+ today: { low: 64, high: 77 },
+ tomorrow: { low: 68, high: 80 }
+};
+
+const { today: { low: lowToday, high: highToday }} = LOCAL_FORECAST;
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md
new file mode 100644
index 00000000000..65739918548
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-assign-variables-from-objects.md
@@ -0,0 +1,97 @@
+---
+id: 587d7b89367417b2b2512b49
+title: Використовуйте деструктивне привласнення для визначення змінних із масивів
+challengeType: 1
+forumTopicId: 301215
+dashedName: use-destructuring-assignment-to-assign-variables-from-objects
+---
+
+# --description--
+
+Деструктуризація дозволяє вам призначити нове ім'я змінної при вилученні. Щоб зробити це, поставте нове ім'я після двокрапки при призначенні.
+
+Використовуйте то й же об'єкт що і в останньому прикладі:
+
+```js
+const user = { name: 'John Doe', age: 34 };
+```
+
+Розглянемо, як ви можете дати нові імена змінним у призначенні:
+
+```js
+const { name: userName, age: userAge } = user;
+```
+
+Ви можете прочитати це як "отримати значення `user.name` та та назначити нову змінну з назвою `userName`" і т.д. Значення `userName` буде `John Doe`, і значення `userAge` буде числом `34`.
+
+# --instructions--
+
+Замініть два визначення еквівалентами з деструктивного привласнення. Ви все ще призначаєте змінним `highToday` та `highTomorrow` значення `today` та
and `tomorrow` з об'єкту `HIGH_TEMPERATURES`.
+
+# --hints--
+
+Видаліть призначення синтаксису ES5.
+
+```js
+assert(
+ !code.match(/highToday = HIGH_TEMPERATURES\.today/g) &&
+ !code.match(/highTomorrow = HIGH_TEMPERATURES\.tomorrow/g)
+);
+```
+
+Використовуйте деструкцію, щоб створити змінну `highToday`.
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*(today\s*:\s*highToday[^}]*|[^,]*,\s*today\s*:\s*highToday\s*)}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g
+ )
+);
+```
+
+Використовуйте деструкцію, щоб створити змінну `highTomorrow`.
+
+```js
+assert(
+ code.match(
+ /(var|const|let)\s*{\s*(tomorrow\s*:\s*highTomorrow[^}]*|[^,]*,\s*tomorrow\s*:\s*highTomorrow\s*)}\s*=\s*HIGH_TEMPERATURES(;|\s+|\/\/)/g
+ )
+);
+```
+
+`highToday` повинна дорівнювати `77` та `highTomorrow` має бути рівний `80`.
+
+```js
+assert(highToday === 77 && highTomorrow === 80);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+// Only change code below this line
+
+const highToday = HIGH_TEMPERATURES.today;
+const highTomorrow = HIGH_TEMPERATURES.tomorrow;
+
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+const HIGH_TEMPERATURES = {
+ yesterday: 75,
+ today: 77,
+ tomorrow: 80
+};
+
+const { today: highToday, tomorrow: highTomorrow } = HIGH_TEMPERATURES;
+```
diff --git a/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md
new file mode 100644
index 00000000000..6742266e2af
--- /dev/null
+++ b/curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/es6/use-destructuring-assignment-to-extract-values-from-objects.md
@@ -0,0 +1,101 @@
+---
+id: 5cfa550e84205a357704ccb6
+title: Використовуйте деструктивне привласнення для визначення змінних із масивів
+challengeType: 1
+forumTopicId: 301216
+dashedName: use-destructuring-assignment-to-extract-values-from-objects
+---
+
+# --description--
+
+
+```
+
+Люди з вадами зору використовують зчитувачі екрану, що перетворюють контент сайту в аудіо формат. Вони не отримають інформацію, якщо вона подана тільки візуально. Що стосується зображень, програма зчитування з екрану може мати доступ до атрибуту `alt` і зчитувати їхній вміст, щоб передати ключову інформацію.
+
+Якісний текст атрибуту `alt` надає програмі зчитування з екрану короткий опис зображення. Завжди додавайте атрибут `alt` до вашого зображення. Згідно зі специфікаціями HTML5, наразі це вважається обов'язковим.
+
+# --instructions--
+
+Кіт Кампер є одночасно ніндзя-кодувальником і справжнім ніндзя, який створює сайт, щоб поділитися знаннями. Фото профілю, яке він використовує, відображає його навички, тож усім відвідувачам сайту слід його цінувати. Додайте атрибут `alt` в тег `img`, який пояснює, що Кіт Кампер займається карате. (Зображення `src` не має посилання на існуючий файл, тож ви маєте побачити текст `alt` на дисплеї.)
+
+# --hints--
+
+Ваш теґ `img` повинен містити атрибут `alt` і не має бути порожнім.
+
+```js
+assert($('img').attr('alt'));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+
+```
+
+# --solutions--
+
+```html
+
+ 
+ 
+```
+
+Фонові зображення також підпадають під мітку "декоративні". Однак вони зазвичай застосовуються з правилами CSS, і тому не є частиною процесу читання з екрану.
+
+**Примітка:** Для зображень із підписом ви все одно можете додати `alt` текст, оскільки це допомагає пошуковим системам класифікувати вміст зображення.
+
+# --instructions--
+
+Camper Cat закодували макет сторінки для розділу блогу на своєму вебсайті. Вони планують додати візуальний розрив між двома статтями з декоративним зображенням самурайського меча. Додайте атрибут `alt` до тегу `img` і присвойте йому порожній рядок. (Зверніть увагу, що зображення `src` не посилається на фактичний файл — не хвилюйтесь, що на дисплеї не відображаються мечі.)
+
+# --hints--
+
+Ваш тег `img` має містити атрибут `alt`.
+
+```js
+assert(!($('img').attr('alt') == undefined));
+```
+
+Атрибуту `alt` має бути призначений порожній рядок.
+
+```js
+assert($('img').attr('alt') == '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```html
+