gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore(i18n,curriculum): processed translations - new ukrainian (#44447)

Browse Source
This commit is contained in:
camperbot
2021-12-10 11:14:24 +05:30
committed by GitHub
parent 8651ee1797
commit 0473dedf47
1663 changed files with 156692 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md Normal file
View File

@@ -0,0 +1,82 @@
---
id: 5a661e0f1068aca922b3ef17
title: Використання дужок для доступу до вмісту масиву
challengeType: 1
forumTopicId: 301149
dashedName: access-an-arrays-contents-using-bracket-notation
---
# --description--
Фундаментальною особливістю будь-якої структури даних, звичайно ж, є можливість не тільки зберігати дані, але і мати можливість отримувати ці дані по команді. Отже, тепер, коли ми дізналися, як створити масив, давайте подумаєте над тим, як ми можемо отримати доступ до інформації цього масиву.
Коли ми визначаємо простий масив як показано нижче, в ньому є 3 елементи:
```js
let ourArray = ["a", "b", "c"];
```
У масиві кожен елемент масиву має <dfn>індекс</dfn>. Цей індекс подвоюється як позиція цього елемента в масиві і як ви на нього посилаєтесь. Проте важливо зазначити, що масиви JavaScript мають <dfn>нульовий індекс</dfn>це означає, що перший елемент масиву фактично знаходиться в ***нульовій*** позиції, а не в першій. Щоб отримати елемент з масиву, ми можемо помістити індекс в дужки і додати його в кінець масиву або, що відбувається частіше, до змінної, яка посилається на об'єкт масиву. Такий спосіб називають <dfn>дужки</dfn>. Наприклад, якщо ми хочемо отримати `a` з `ourArray` та призначити йому змінну, ми можемо зробити це за допомогою наступного коду:
```js
let ourVariable = ourArray[0];
```
Тепер `ourVariable` має значення `a`.
Крім доступу до значення, пов'язаного з індексом, ви також можете* встановити *індекс для значення, використовуючи таке ж позначення:
```js
ourArray[1] = "not b anymore";
```
Використовуючи дужки, ми скинули елемент з індексом 1 з рядка `b`, на `not b anymore`. Тепер `ourArray` це `["a", "not b anymore", "c"]`.
# --instructions--
Щоб виконати це завдання, встановіть другу позицію (index `1`) для `myArray` на все, що захочете, крім букви `b`.
# --hints--
`myArray[0]` повинен дорівнювати букві `a`
```js
assert.strictEqual(myArray[0], 'a');
```
`myArray[1]` не повинен дорівнювати букві `b`
```js
assert.notStrictEqual(myArray[1], 'b');
```
`myArray[2]` повинен дорівнювати букві `c`
```js
assert.strictEqual(myArray[2], 'c');
```
`myArray[3]` повинен дорівнювати букві `d`
```js
assert.strictEqual(myArray[3], 'd');
```
# --seed--
## --seed-contents--
```js
let myArray = ["a", "b", "c", "d"];
// Only change code below this line
// Only change code above this line
console.log(myArray);
```
# --solutions--
```js
let myArray = ["a", "b", "c", "d"];
myArray[1] = "e";
```

101
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md Normal file
View File

@@ -0,0 +1,101 @@
---
id: 587d7b7c367417b2b2512b1a
title: Доступ до назв властивостей за допомогою дужок
challengeType: 1
forumTopicId: 301150
dashedName: access-property-names-with-bracket-notation
---
# --description--
У першому завданні про об'єкт ми згадували використання дужок як спосіб доступу до значень властивостей за допомогою оцінювання змінної. Наприклад, уявіть, що наш об'єкт `foods` використовується в програмі для касового апарату супермаркету. У нас є функція, яка встановлює `selectedFood` і ми хочемо перевірити наш об'єкт `foods` на наявність цієї їжі. Це може виглядати так:
```js
let selectedFood = getCurrentFood(scannedItem);
let inventory = foods[selectedFood];
```
Цей код оцінить значення, яке зберігається в змінній `selectedFood` та поверне значення цього ключа в об'єкт`foods`, або `undefined` якщо він відсутній. Дужки дуже корисні, тому що іноді властивості об'єкта невідомі до часу виконання або нам потрібно отримати до них доступ більш динамічним способом.
# --instructions--
Ми визначили функцію, `checkInventory`, яка отримує відсканований елемент в якості аргументу. Повернути поточне значення ключа `scannedItem` в об'єкті `foods`. Ви можете припустити, що тільки дійсні ключі будуть надані в якості аргументу для `checkInventory`.
# --hints--
`checkInventory` повинен бути функцією.
```js
assert.strictEqual(typeof checkInventory, 'function');
```
Об'єкт `foods` повинен мати тільки наступні пари ключових значень: `apples: 25`, `oranges: 32`, `plums: 28`, `bananas: 13`, `grapes: 35`, `strawberries: 27`.
```js
assert.deepEqual(foods, {
apples: 25,
oranges: 32,
plums: 28,
bananas: 13,
grapes: 35,
strawberries: 27
});
```
`checkInventory("apples")` повинен повернути `25`.
```js
assert.strictEqual(checkInventory('apples'), 25);
```
`checkInventory("bananas")` повинен повернути `13`.
```js
assert.strictEqual(checkInventory('bananas'), 13);
```
`checkInventory("strawberries")` повинен повернути `27`.
```js
assert.strictEqual(checkInventory('strawberries'), 27);
```
# --seed--
## --seed-contents--
```js
let foods = {
apples: 25,
oranges: 32,
plums: 28,
bananas: 13,
grapes: 35,
strawberries: 27
};
function checkInventory(scannedItem) {
// Only change code below this line
// Only change code above this line
}
console.log(checkInventory("apples"));
```
# --solutions--
```js
let foods = {
apples: 25,
oranges: 32,
plums: 28,
bananas: 13,
grapes: 35,
strawberries: 27
};
function checkInventory(scannedItem) {
return foods[scannedItem];
}
```

87
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md Normal file
View File

@@ -0,0 +1,87 @@
---
id: 587d78b2367417b2b2512b0e
title: Додати елементи в масив за допомогою функцій push() і unshift()
challengeType: 1
forumTopicId: 301151
dashedName: add-items-to-an-array-with-push-and-unshift
---
# --description--
Довжина масиву, як і типи даних, які він може містити, не фіксована. Масиви можуть бути створені з будь-якою кількістю елементів, і елементи можуть бути додані або видалені з плином часу; іншими словами, масиви <dfn> мінливі</dfn>. У цьому завданні ми розглянемо два методи, за допомогою яких ми можемо програмно змінювати масив: `Array.push()` і `Array.unshift()`.
Обидва методи приймають один або кілька елементів в якості параметрів і додають ці елементи в масив, для якого викликається метод; метод `push()` додає елементи в кінець масиву, а `unshift()` додає елементи на початок. Зверніть увагу:
```js
let twentyThree = 'XXIII';
let romanNumerals = ['XXI', 'XXII'];
romanNumerals.unshift('XIX', 'XX');
```
`romanNumerals` мав би значення `['XIX', 'XX', 'XXI', 'XXII']`.
```js
romanNumerals.push(twentyThree);
```
`romanNumerals` мав би значення `['XIX', 'XX', 'XXI', 'XXII', 'XXIII']`. Зверніть увагу, що ми також можемо передавати змінні, що дає нам ще більшу гнучкість при динамічній зміні даних нашого масиву.
# --instructions--
Ми визначили функцію, `mixedNumbers`, якій ми передаємо масив як аргумент. Змініть функцію за допомогою `push()` та`unshift()` щоб додати `'I', 2, 'three'` на початок масиву і `7, 'VIII', 9` в кінець, щоб повернутий масив містив числа 1-9 по порядку.
# --hints--
`mixedNumbers(["IV", 5, "six"])` тепер повинен повернути `["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]`
```js
assert.deepEqual(mixedNumbers(['IV', 5, 'six']), [
'I',
2,
'three',
'IV',
5,
'six',
7,
'VIII',
9
]);
```
Функція `mixedNumbers` повинна використовувати `push()` метод
```js
assert(mixedNumbers.toString().match(/\.push/));
```
Функція `mixedNumbers` повинна використовувати `unshift()` метод
```js
assert(mixedNumbers.toString().match(/\.unshift/));
```
# --seed--
## --seed-contents--
```js
function mixedNumbers(arr) {
// Only change code below this line
// Only change code above this line
return arr;
}
console.log(mixedNumbers(['IV', 5, 'six']));
```
# --solutions--
```js
function mixedNumbers(arr) {
arr.push(7,'VIII',9);
arr.unshift('I',2,'three');
return arr;
}
```

93
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md Normal file
View File

@@ -0,0 +1,93 @@
---
id: 587d78b3367417b2b2512b11
title: Видалити елементи за допомогою функції splice()
challengeType: 1
forumTopicId: 301152
dashedName: add-items-using-splice
---
# --description--
Пам'ятаєте, в попередньому завданні ми згадували, що `splice()` може приймати до трьох параметрів? Що ж, ви можете використовувати третій параметр, що складається з одного або декількох елементів, для додавання в масив. Це може бути неймовірно корисно для швидкої зміни елемента або набору елементів для іншого елемента.
```js
const numbers = [10, 11, 12, 12, 15];
const startIndex = 3;
const amountToDelete = 1;
numbers.splice(startIndex, amountToDelete, 13, 14);
console.log(numbers);
```
В другому випадку `12` видалений, і ми додаємо `13` і `14` до того ж індексу. Тепер масив `numbers` буде мати вигляд `[ 10, 11, 12, 13, 14, 15 ]`.
Тут ми починаємо з масиву чисел. Потім ми передаємо в `splice()` наступне: індекс, з якого слід почати видалення елементів (3), кількість елементів, які потрібно видалити (1), і решта аргументів (13, 14) будуть вставлені, починаючи з того ж індексу. Зверніть увагу, що після `amountToDelete` може бути будь-яка кількість елементів (розділених комами), кожен з яких вставляється.
# --instructions--
Ми визначили функцію `htmlColorNames`, яка приймає в якості аргументу масив кольорів HTML. Змініть функцію за допомогою `splice()`, щоб видалити перші два елементи масиву і додати `'DarkSalmon'` та `'BlanchedAlmond'` на свої місця.
# --hints--
`htmlColorNames` повинен повернути `["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurquoise", "FireBrick"]`
```js
assert.deepEqual(
htmlColorNames([
'DarkGoldenRod',
'WhiteSmoke',
'LavenderBlush',
'PaleTurquoise',
'FireBrick'
]),
[
'DarkSalmon',
'BlanchedAlmond',
'LavenderBlush',
'PaleTurquoise',
'FireBrick'
]
);
```
Функція `htmlColorNames` повинна використовувати `splice()` метод
```js
assert(/.splice/.test(code));
```
Вам не слід використовувати `shift()` або `unshift()`.
```js
assert(!/shift|unshift/.test(code));
```
Вам не слід використовувати дужки масиву.
```js
assert(!/\[\d\]\s*=/.test(code));
```
# --seed--
## --seed-contents--
```js
function htmlColorNames(arr) {
// Only change code below this line
// Only change code above this line
return arr;
}
console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurquoise', 'FireBrick']));
```
# --solutions--
```js
function htmlColorNames(arr) {
arr.splice(0,2,'DarkSalmon', 'BlanchedAlmond');
return arr;
}
```

124
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md Normal file
View File

@@ -0,0 +1,124 @@
---
id: 587d7b7c367417b2b2512b18
title: Додавання пар Key-Value (ключ-значення) до об'єктів JavaScript
challengeType: 1
forumTopicId: 301153
dashedName: add-key-value-pairs-to-javascript-objects
---
# --description--
По суті, об'єкти - це просто набори пар <dfn>ключ-значення</dfn>. Іншими словами, це фрагменти даних (<dfn>значення</dfn>), зіставлені з унікальними ідентифікаторами, що називаються <dfn>властивостями</dfn> (<dfn>ключами</dfn>). Розглянемо приклад:
```js
const tekkenCharacter = {
player: 'Hwoarang',
fightingStyle: 'Tae Kwon Doe',
human: true
};
```
Наведений вище код називає об'єкт персонажа відеоігри Tekken з ім'ям `tekkenCharacter`. У нього є три властивості, кожна з яких відповідає певному значенню. Якщо ви хочете додати додаткову властивість, таку як "origin", це можна зробити, призначивши `origin` об’єкту:
```js
tekkenCharacter.origin = 'South Korea';
```
Тут використовується крапкова нотація. Якщо ви спостерігали за об'єктом `tekkenCharacter`, то тепер він містить властивість `origin`. У Хвоаранга також було яскраво-помаранчеве волосся. Ви можете додати цю властивість в дужки, виконавши:
```js
tekkenCharacter['hair color'] = 'dyed orange';
```
Позначення в дужках потрібно, якщо у вашій властивості є пробіл або якщо ви хочете використовувати змінну для імені властивості. У наведеному вище випадку властивість розміщується в лапках, щоб позначити її як рядок і вона буде додана точно так, як показано. Без лапок вона буде оцінюватися як змінна, а ім'я властивості буде мати будь-яке значення змінної. Ось приклад зі змінною:
```js
const eyes = 'eye color';
tekkenCharacter[eyes] = 'brown';
```
Після додавання всіх прикладів об'єкт буде виглядати так:
```js
{
player: 'Hwoarang',
fightingStyle: 'Tae Kwon Doe',
human: true,
origin: 'South Korea',
'hair color': 'dyed orange',
'eye color': 'brown'
};
```
# --instructions--
Об'єкт `foods` був створений з трьома записами. Використовуючи обраний синтаксис, додайте до нього ще три записи: `bananas` із значенням `13`, `grapes` із значенням `35`, та `strawberries` із значенням `27`.
# --hints--
`foods` повинен бути об'єктом.
```js
assert(typeof foods === 'object');
```
Об'єкт `foods` повинен мати ключ `bananas` зі значенням `13`.
```js
assert(foods.bananas === 13);
```
Об'єкт `foods` повинен мати ключ `grapes` зі значенням `35`.
```js
assert(foods.grapes === 35);
```
Об'єкт `foods` повинен мати ключ `strawberries` зі значенням `27`.
```js
assert(foods.strawberries === 27);
```
Пари "ключ-значення" повинні бути встановлені за допомогою крапок або дужок.
```js
assert(
code.search(/bananas:/) === -1 &&
code.search(/grapes:/) === -1 &&
code.search(/strawberries:/) === -1
);
```
# --seed--
## --seed-contents--
```js
let foods = {
apples: 25,
oranges: 32,
plums: 28
};
// Only change code below this line
// Only change code above this line
console.log(foods);
```
# --solutions--
```js
let foods = {
apples: 25,
oranges: 32,
plums: 28
};
foods['bananas'] = 13;
foods['grapes'] = 35;
foods['strawberries'] = 27;
```

93
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md Normal file
View File

@@ -0,0 +1,93 @@
---
id: 587d7b7b367417b2b2512b14
title: Перевірка наявності елемента за допомогою indexOf()
challengeType: 1
forumTopicId: 301154
dashedName: check-for-the-presence-of-an-element-with-indexof
---
# --description--
Оскільки масиви можуть бути змінені або *mutated* в будь-який час, немає ніяких гарантій щодо того, де конкретний фрагмент даних буде знаходитися в даному масиві, або що цей елемент все ще існує. На щастя, JavaScript надає нам ще один вбудований метод, `indexOf()`, який дозволяє нам швидко і легко перевіряти наявність елемента в масиві. `indexOf()` приймає елемент як параметр і при запиті - повертає позицію або індекс цього елемента або `-1`, якщо елементу в масиві немає.
Наприклад:
```js
let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];
fruits.indexOf('dates');
fruits.indexOf('oranges');
fruits.indexOf('pears');
```
`indexOf('dates')` повертає `-1`, `indexOf('oranges')` повертає `2`, і `indexOf('pears')` повертає `1` (перший індекс, за яким існує кожен елемент).
# --instructions--
`indexOf()` може бути неймовірно корисним для швидкої перевірки наявності елемента в масиві. Ми визначили функцію `quickCheck`, яка приймає в якості аргументів масив і елемент. Змініть функцію використовуючи `indexOf()` так, щоб вона повернула `true` якщо переданий елемент існує в масиві, та `false` якщо не існує.
# --hints--
Функція `quickCheck` повинна повернути логічне значення (`true` або `false`), а не рядок (`"true"` або `"false"`)
```js
assert.isBoolean(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
```
`quickCheck(["squash", "onions", "shallots"], "mushrooms")` повинна повернути `false`
```js
assert.strictEqual(
quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'),
false
);
```
`quickCheck(["onions", "squash", "shallots"], "onions")` повинна повернути `true`
```js
assert.strictEqual(
quickCheck(['onions', 'squash', 'shallots'], 'onions'),
true
);
```
`quickCheck([3, 5, 9, 125, 45, 2], 125)` повинна повернути `true`
```js
assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true);
```
`quickCheck([true, false, false], undefined)` повинна повернути `false`
```js
assert.strictEqual(quickCheck([true, false, false], undefined), false);
```
Функція `quickCheck` повинна використовувати метод `indexOf()`
```js
assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1);
```
# --seed--
## --seed-contents--
```js
function quickCheck(arr, elem) {
// Only change code below this line
// Only change code above this line
}
console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
```
# --solutions--
```js
function quickCheck(arr, elem) {
return arr.indexOf(elem) >= 0;
}
```

161
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md Normal file
View File

@@ -0,0 +1,161 @@
---
id: 587d7b7d367417b2b2512b1c
title: Перевірте, чи має об'єкт властивість
challengeType: 1
forumTopicId: 301155
dashedName: check-if-an-object-has-a-property
---
# --description--
Тепер ми можемо додавати, змінювати та видаляти ключі з об'єктів. А якщо ми просто хочемо знати, чи об'єкт має конкретну властивість? JavaScript надає нам два різних способи це зробити. Один використовує метод `hasOwnProperty()` а інший використовує ключове слово `in`. Якщо у нас є об'єкт `users` з властивістю `Alan`, ми можемо перевірити її наявність одним із таких способів:
```js
users.hasOwnProperty('Alan');
'Alan' in users;
```
Обидва вони повернуть `true`.
# --instructions--
Завершіть написання функції таким чином, щоб вона повертала true, якщо переданий їй об'єкт містить всі чотири імені: `Alan`, `Jeff`, `Sarah` і `Ryan`, а в іншому випадку - щоб повертала false.
# --hints--
До об'єкту `users` не можна звертатися безпосередньо
```js
assert(code.match(/users/gm).length <= 2)
```
Об'єкт `users` повинен містити тільки ключі `Alan`, `Jeff`, `Sarah`, та `Ryan`
```js
assert(
'Alan' in users &&
'Jeff' in users &&
'Sarah' in users &&
'Ryan' in users &&
Object.keys(users).length === 4
);
```
Функція `isEveryoneHere` повинна повертати `true` якщо `Alan`, `Jeff`, `Sarah`, та `Ryan` це властивості переданого їй об'єкту.
```js
assert(isEveryoneHere(users) === true);
```
Функція `isEveryoneHere` повинна повернути `false` якщо `Alan` не є властивістю переданого їй об'єкту.
```js
assert(
(function () {
delete users.Alan;
return isEveryoneHere(users);
})() === false
);
```
Функція `isEveryoneHere` повинна повернути`false` якщо `Jeff` не є властивістю переданого їй об'єкту.
```js
assert(
(function () {
delete users.Jeff;
return isEveryoneHere(users);
})() === false
);
```
Функція `isEveryoneHere` повинна повернути `false` якщо `Sarah` не є властивістю переданого їй об'єкту.
```js
assert(
(function () {
delete users.Sarah;
return isEveryoneHere(users);
})() === false
);
```
Функція `isEveryoneHere` повинна повернути `false` якщо `Ryan` не є властивістю переданого їй об'єкту.
```js
assert(
(function () {
delete users.Ryan;
return isEveryoneHere(users);
})() === false
);
```
# --seed--
## --seed-contents--
```js
let users = {
Alan: {
age: 27,
online: true
},
Jeff: {
age: 32,
online: true
},
Sarah: {
age: 48,
online: true
},
Ryan: {
age: 19,
online: true
}
};
function isEveryoneHere(userObj) {
// Only change code below this line
// Only change code above this line
}
console.log(isEveryoneHere(users));
```
# --solutions--
```js
let users = {
Alan: {
age: 27,
online: true
},
Jeff: {
age: 32,
online: true
},
Sarah: {
age: 48,
online: true
},
Ryan: {
age: 19,
online: true
}
};
function isEveryoneHere(userObj) {
return [
'Alan',
'Jeff',
'Sarah',
'Ryan'
].every(user => userObj.hasOwnProperty(user));
}
console.log(isEveryoneHere(users));
```

63
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md Normal file
View File

@@ -0,0 +1,63 @@
---
id: 587d7b7b367417b2b2512b17
title: Об'єднайте масиви з Spread-оператором
challengeType: 1
forumTopicId: 301156
dashedName: combine-arrays-with-the-spread-operator
---
# --description--
Ще одна величезна перевага <dfn>spread</dfn>-оператора - це можливість комбінувати масиви або вставляти всі елементи одного масиву в інший по будь-якому індексу. Використовуючи більш традиційні види синтаксу, ми можемо об'єднувати масиви, але це дозволяє нам об'єднувати масиви тільки в кінці одного і на початку іншого. Функція Spread Synrax робить наступну операцію надзвичайно простою:
```js
let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];
let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];
```
`thatArray` буде мати значення `['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']`.
Використовуючи функцію spread synrax, ми щойно виконали операцію, яка була б складнішою і більш детальною, якби ми використовували традиційні методи.
# --instructions--
Ми визначили функцію `spreadOut`, яка повертає змінну `sentence`. Змініть функцію використовуючи <dfn>spread</dfn> оператор, щоб вона повертала масив `['learning', 'to', 'code', 'is', 'fun']`.
# --hints--
`spreadOut` повинен повернути `["learning", "to", "code", "is", "fun"]`
```js
assert.deepEqual(spreadOut(), ['learning', 'to', 'code', 'is', 'fun']);
```
Функція `spreadOut` повинна використовувати spread syntax
```js
assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1);
```
# --seed--
## --seed-contents--
```js
function spreadOut() {
let fragment = ['to', 'code'];
let sentence; // Change this line
return sentence;
}
console.log(spreadOut());
```
# --solutions--
```js
function spreadOut() {
let fragment = ['to', 'code'];
let sentence = ['learning', ...fragment, 'is', 'fun'];
return sentence;
}
```

102
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md Normal file
View File

@@ -0,0 +1,102 @@
---
id: 587d7b7b367417b2b2512b13
title: Скопіюйте масив з Spread-оператором
challengeType: 1
forumTopicId: 301157
dashedName: copy-an-array-with-the-spread-operator
---
# --description--
Хоча `slice()` дозволяє нам вибирати, які елементи масиву копіювати, серед кількох інших корисних завдань, новий <dfn>spread-оператор</dfn> ES6 дозволяє нам легко копіювати *all* елементи масиву, по порядку, з простим і дуже читабельним синтаксисом. Spread синтаксис виглядає так: `...`
На практиці ми можемо використати spread-оператор для копіювання масиву таким чином:
```js
let thisArray = [true, true, undefined, false, null];
let thatArray = [...thisArray];
```
`thatArray` дорівнює `[true, true, undefined, false, null]`. `thisArray` залишається без змін і `thatArray` містить ті ж елементи, що й `thisArray`.
# --instructions--
Ми визначили функцію, `copyMachine`, яка приймає `arr` (масив) та `num` (номер) як аргументи. Функція повинна повертати новий масив, що складається з `num` копій `arr`. Ми виконали більшу частину роботи за вас, але це поки не працює. Змініть функцію, використовуючи spread синтаксис, щоб вона працювала правильно (підказка: тут може стати в нагоді інший метод, який ми вже розглядали!).
# --hints--
`copyMachine([true, false, true], 2)` повинна повернути `[[true, false, true], [true, false, true]]`
```js
assert.deepEqual(copyMachine([true, false, true], 2), [
[true, false, true],
[true, false, true]
]);
```
`copyMachine([1, 2, 3], 5)` повинна повернути `[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]`
```js
assert.deepEqual(copyMachine([1, 2, 3], 5), [
[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]
]);
```
`copyMachine([true, true, null], 1)` повинна повернути `[[true, true, null]]`
```js
assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]]);
```
`copyMachine(["it works"], 3)` повинна повернути `[["it works"], ["it works"], ["it works"]]`
```js
assert.deepEqual(copyMachine(['it works'], 3), [
['it works'],
['it works'],
['it works']
]);
```
Функція `copyMachine` повинна використовувати `spread operator` з масивом `arr`
```js
assert(code.match(/\.\.\.arr/));
```
# --seed--
## --seed-contents--
```js
function copyMachine(arr, num) {
let newArr = [];
while (num >= 1) {
// Only change code below this line
// Only change code above this line
num--;
}
return newArr;
}
console.log(copyMachine([true, false, true], 2));
```
# --solutions--
```js
function copyMachine(arr,num){
let newArr=[];
while(num >=1){
newArr.push([...arr]);
num--;
}
return newArr;
}
console.log(copyMachine([true, false, true], 2));
```

65
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md Normal file
View File

@@ -0,0 +1,65 @@
---
id: 587d7b7a367417b2b2512b12
title: Скопіювати елементи масиву використовуючи slice()
challengeType: 1
forumTopicId: 301158
dashedName: copy-array-items-using-slice
---
# --description--
Наступний метод, який ми розглянемо це `slice()`. Замість зміни масиву `slice()` копіює або *extracts* задану кількість елементів в новий масив, залишаючи масив, для якого він викликається, незмінним. `slice()`приймає лише 2 параметри: перший - це індекс, з якого починається вибірка, а другий - індекс, за яким вибірка припиняється (вибірка відбуватиметься, але не включаючи елемент у цьому індексі). Врахуйте це:
```js
let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];
let todaysWeather = weatherConditions.slice(1, 3);
```
`todaysWeather` матиме значення `['snow', 'sleet']`, хоча `weatherConditions` як і раніше буде мати `['rain', 'snow', 'sleet', 'hail', 'clear']`.
Фактично, ми створили новий масив, вибираючи елементи з масиву, який вже існує.
# --instructions--
Ми визначили функцію `forecast`, яка приймає масив як аргумент. Змініть функцію за допомогою `slice()`, щоб вибрати інформацію з масиву аргументів і повернути новий масив, що містить елементи рядка `warm` і `sunny`.
# --hints--
`forecast` повинна повернути `["warm", "sunny"]`
```js
assert.deepEqual(
forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']),
['warm', 'sunny']
);
```
Функція `forecast` повинна використовувати `slice()` метод
```js
assert(/\.slice\(/.test(code));
```
# --seed--
## --seed-contents--
```js
function forecast(arr) {
// Only change code below this line
return arr;
}
// Only change code above this line
console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']));
```
# --solutions--
```js
function forecast(arr) {
return arr.slice(2,4);
}
```

218
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md Normal file
View File

@@ -0,0 +1,218 @@
---
id: 587d7b7b367417b2b2512b16
title: Створення комплексних багатовимірних масивів
challengeType: 1
forumTopicId: 301159
dashedName: create-complex-multi-dimensional-arrays
---
# --description--
Чудово! Ви щойно дізналися багато нового про масиви! Це був досить загальний огляд, і є ще багато чого, що потрібно дізнатися про роботу з масивами, багато чого ви побачите в наступних розділах. Але перш ніж перейти до розгляду <dfn>Objects</dfn>, давайте ще раз глянемо і подивимося, яким чином масиви можуть стати дещо складнішими за ті, які ми бачили в попередніх завданнях.
Одна з найпотужніших функцій при розгляді масивів як структур даних полягає в тому, що масиви можуть містити або навіть повністю складатися з інших масивів. У попередніх завданнях ми бачили масиви, які містять масиви, але досить прості. Однак масиви можуть містити нескінченну глибину масивів, які можуть містити інші масиви, кожен зі своїми довільними рівнями глибини і так далі. Таким чином, масив може дуже швидко перетворитися в дуже складну структуру даних, відому як <dfn>multi-dimensional</dfn> або вкладений масив. Розглянемо наступний приклад:
```js
let nestedArray = [
['deep'],
[
['deeper'], ['deeper']
],
[
[
['deepest'], ['deepest']
],
[
[
['deepest-est?']
]
]
]
];
```
Масив `deep` вкладений на глибину 2 рівня. Масиви `deeper` мають глибину третього рівня. Масиви `deepest` мають 4 рівень, а `deepest-est?` - 5.
Хоча цей приклад може здатися заплутаним, такий рівень складності не є чимось незвичним або навіть незвичайним при роботі з великими обсягами даних. Тим не менш, ми все ще можемо дуже легко отримати доступ до найглибших рівнів масиву цього складного масиву за допомогою дужок:
```js
console.log(nestedArray[2][1][0][0][0]);
```
Це записує рядок `deepest-est?`. І тепер, коли ми знаємо, де знаходиться цей фрагмент даних, ми можемо скинути його, якщо нам потрібно:
```js
nestedArray[2][1][0][0][0] = 'deeper still';
console.log(nestedArray[2][1][0][0][0]);
```
Тепер він записує `deeper still`.
# --instructions--
Ми визначили змінну `myNestedArray`, що дорівнює масиву. Змініть `myNestedArray`, використовуючи будь-яку комбінацію <dfn>strings</dfn>, <dfn>numbers</dfn>, і <dfn>booleans</dfn> для елементів даних, так, щоб він мав точно п'ять рівнів глибини (пам'ятаєте, самий зовнішній масив - це рівень 1). Десь на третьому рівні, додайте рядок `deep`, на четвертому рівні, додайте рядок `deeper` та на п'ятому рівні, додайте рядок `deepest`.
# --hints--
`myNestedArray` повинен містити лише цифри, логічні значення та рядки в якості елементів даних
```js
assert.strictEqual(
(function (arr) {
let flattened = (function flatten(arr) {
const flat = [].concat(...arr);
return flat.some(Array.isArray) ? flatten(flat) : flat;
})(arr);
for (let i = 0; i < flattened.length; i++) {
if (
typeof flattened[i] !== 'number' &&
typeof flattened[i] !== 'string' &&
typeof flattened[i] !== 'boolean'
) {
return false;
}
}
return true;
})(myNestedArray),
true
);
```
`myNestedArray` повинен мати рівно 5 рівнів глибини
```js
assert.strictEqual(
(function (arr) {
let depth = 0;
function arrayDepth(array, i, d) {
if (Array.isArray(array[i])) {
arrayDepth(array[i], 0, d + 1);
} else {
depth = d > depth ? d : depth;
}
if (i < array.length) {
arrayDepth(array, i + 1, d);
}
}
arrayDepth(arr, 0, 0);
return depth;
})(myNestedArray),
4
);
```
`myNestedArray` повинен містити рівно одне входження рядка `deep` в масиві, вкладеному в 3 рівень глибини
```js
assert(
(function howDeep(array, target, depth = 0) {
return array.reduce((combined, current) => {
if (Array.isArray(current)) {
return combined.concat(howDeep(current, target, depth + 1));
} else if (current === target) {
return combined.concat(depth);
} else {
return combined;
}
}, []);
})(myNestedArray, 'deep').length === 1 &&
(function howDeep(array, target, depth = 0) {
return array.reduce((combined, current) => {
if (Array.isArray(current)) {
return combined.concat(howDeep(current, target, depth + 1));
} else if (current === target) {
return combined.concat(depth);
} else {
return combined;
}
}, []);
})(myNestedArray, 'deep')[0] === 2
);
```
`myNestedArray` повинен містити рівно одне входження рядка `deeper` в масиві, вкладеному в 4 рівень глибини
```js
assert(
(function howDeep(array, target, depth = 0) {
return array.reduce((combined, current) => {
if (Array.isArray(current)) {
return combined.concat(howDeep(current, target, depth + 1));
} else if (current === target) {
return combined.concat(depth);
} else {
return combined;
}
}, []);
})(myNestedArray, 'deeper').length === 1 &&
(function howDeep(array, target, depth = 0) {
return array.reduce((combined, current) => {
if (Array.isArray(current)) {
return combined.concat(howDeep(current, target, depth + 1));
} else if (current === target) {
return combined.concat(depth);
} else {
return combined;
}
}, []);
})(myNestedArray, 'deeper')[0] === 3
);
```
`myNestedArray` повинен містити рівно одне входження рядка `deepest` в масиві, вкладеному в 5 рівень глибини
```js
assert(
(function howDeep(array, target, depth = 0) {
return array.reduce((combined, current) => {
if (Array.isArray(current)) {
return combined.concat(howDeep(current, target, depth + 1));
} else if (current === target) {
return combined.concat(depth);
} else {
return combined;
}
}, []);
})(myNestedArray, 'deepest').length === 1 &&
(function howDeep(array, target, depth = 0) {
return array.reduce((combined, current) => {
if (Array.isArray(current)) {
return combined.concat(howDeep(current, target, depth + 1));
} else if (current === target) {
return combined.concat(depth);
} else {
return combined;
}
}, []);
})(myNestedArray, 'deepest')[0] === 4
);
```
# --seed--
## --seed-contents--
```js
let myNestedArray = [
// Only change code below this line
['unshift', false, 1, 2, 3, 'complex', 'nested'],
['loop', 'shift', 6, 7, 1000, 'method'],
['concat', false, true, 'spread', 'array'],
['mutate', 1327.98, 'splice', 'slice', 'push'],
['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
// Only change code above this line
];
```
# --solutions--
```js
let myNestedArray = [
['unshift', ['deep', ['deeper', ['deepest']]],false, 1, 2, 3, 'complex', 'nested'],
['loop', 'shift', 6, 7, 1000, 'method'],
['concat', false, true, 'spread', 'array'],
['mutate', 1327.98, 'splice', 'slice', 'push'],
['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth']
];
```

111
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md Normal file
View File

@@ -0,0 +1,111 @@
---
id: 587d7b7d367417b2b2512b1e
title: Створення масиву всіх ключів об’єкта за допомогою Object.keys()
challengeType: 1
forumTopicId: 301160
dashedName: generate-an-array-of-all-object-keys-with-object-keys
---
# --description--
Ми також можемо створити масив який містить всі ключі що зберігаються в об’єкті за допомогою методу `Object.keys()` і передавши об'єкт в якості аргументу. Це поверне масив з рядками, що представляють кожну властивість об'єкта. Знову ж таки, не буде певного порядку записів в масиві.
# --instructions--
Завершіть написання функції `getArrayOfUsers`, щоб вона повертала масив, що містить всі властивості об'єкта, який він отримує в якості аргументу.
# --hints--
Об'єкт `users` повинен містити тільки ключі `Alan`, `Jeff`, `Sarah`, та `Ryan`
```js
assert(
'Alan' in users &&
'Jeff' in users &&
'Sarah' in users &&
'Ryan' in users &&
Object.keys(users).length === 4
);
```
Функція `getArrayOfUsers` повинна повернути масив, який містить усі ключі в об’єкті `users`
```js
assert(
(function () {
users.Sam = {};
users.Lewis = {};
let R = getArrayOfUsers(users);
return (
R.indexOf('Alan') !== -1 &&
R.indexOf('Jeff') !== -1 &&
R.indexOf('Sarah') !== -1 &&
R.indexOf('Ryan') !== -1 &&
R.indexOf('Sam') !== -1 &&
R.indexOf('Lewis') !== -1
);
})() === true
);
```
# --seed--
## --seed-contents--
```js
let users = {
Alan: {
age: 27,
online: false
},
Jeff: {
age: 32,
online: true
},
Sarah: {
age: 48,
online: false
},
Ryan: {
age: 19,
online: true
}
};
function getArrayOfUsers(obj) {
// Only change code below this line
// Only change code above this line
}
console.log(getArrayOfUsers(users));
```
# --solutions--
```js
let users = {
Alan: {
age: 27,
online: false
},
Jeff: {
age: 32,
online: true
},
Sarah: {
age: 48,
online: false
},
Ryan: {
age: 19,
online: true
}
};
function getArrayOfUsers(obj) {
return Object.keys(obj);
}
console.log(getArrayOfUsers(users));
```

138
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md Normal file
View File

@@ -0,0 +1,138 @@
---
id: 587d7b7b367417b2b2512b15
title: Ітерація через усі масиви за допомогою циклів
challengeType: 1
forumTopicId: 301161
dashedName: iterate-through-all-an-arrays-items-using-for-loops
---
# --description--
Іноді при роботі з масивами дуже зручно мати можливість перебирати кожен елемент, щоб знайти один або кілька елементів, які можуть нам знадобитися, або керувати масивом в залежності від того, які елементи даних відповідають певному набору критеріїв. JavaScript надає різні побудови в методах, що ітерують крізь масиви й надають змогу досягнути певних результатів різними шляхами (such as `every()`, `forEach()`, `map()`, etc.). Однак, ця техніка є гнучкою й більш спроможна до контролю `for` циклу.
Розглянемо наступний приклад:
```js
function greaterThanTen(arr) {
let newArr = [];
for (let i = 0; i < arr.length; i++) {
if (arr[i] > 10) {
newArr.push(arr[i]);
}
}
return newArr;
}
greaterThanTen([2, 12, 8, 14, 80, 0, 1]);
```
Завдяки використанню `for` у циклі, ця функція ітерує й надає доступ до кожного елементу в масиві простого тесту, який ми створили. Таким чином ми легко й автоматично визначаємо елементи дати, що більше, ніж `10`, й повертаємо новий масив, `[12, 14, 80]`, який містить ці елементи.
# --instructions--
Ми встановили функцію, `filteredArray`, яка обирає `arr`, вкладений масив, `elem` як аргументи, й повертає новий масив. `elem` означає елемент, що може не бути присутнім в одному або більше масивах в межах `arr`. Покращте функцію, використовуючи `for` циклу, для повернення відфільтрованої версії переданого масиву, так щоб версію в межах `arr` зі `elem` було прибрано.
# --hints--
`filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)` має повернути `[[10, 8, 3], [14, 6, 23]]`
```js
assert.deepEqual(
filteredArray(
[
[10, 8, 3],
[14, 6, 23],
[3, 18, 6]
],
18
),
[
[10, 8, 3],
[14, 6, 23]
]
);
```
`filteredArray([["trumpets", 2], ["flutes", 4], ["saxophones", 2]], 2)` має повернути `[["flutes", 4]]`
```js
assert.deepEqual(
filteredArray(
[
['trumpets', 2],
['flutes', 4],
['saxophones', 2]
],
2
),
[['flutes', 4]]
);
```
`filteredArray([["amy", "beth", "sam"], ["dave", "sean", "peter"]], "peter")` має повернути `[["amy", "beth", "sam"]]`
```js
assert.deepEqual(
filteredArray(
[
['amy', 'beth', 'sam'],
['dave', 'sean', 'peter']
],
'peter'
),
[['amy', 'beth', 'sam']]
);
```
`filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)` має повернути `[]`
```js
assert.deepEqual(
filteredArray(
[
[3, 2, 3],
[1, 6, 3],
[3, 13, 26],
[19, 3, 9]
],
3
),
[]
);
```
Функція `filteredArray` повинна використовуватися у циклі `for`
```js
assert.notStrictEqual(filteredArray.toString().search(/for/), -1);
```
# --seed--
## --seed-contents--
```js
function filteredArray(arr, elem) {
let newArr = [];
// Only change code below this line
// Only change code above this line
return newArr;
}
console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3));
```
# --solutions--
```js
function filteredArray(arr, elem) {
let newArr = [];
for (let i = 0; i<arr.length; i++) {
if (arr[i].indexOf(elem) < 0) {
newArr.push(arr[i]);
}
}
return newArr;
}
```

138
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-the-keys-of-an-object-with-a-for...in-statement.md Normal file
View File

@@ -0,0 +1,138 @@
---
id: 587d7b7d367417b2b2512b1d
title: Ітерація через ключі об'єкта у циклі "for...in"
challengeType: 1
forumTopicId: 301162
dashedName: iterate-through-the-keys-of-an-object-with-a-for---in-statement
---
# --description--
Часом вам треба буде ітерувати всі ключі всередині об'єкта. У JavaScript це вимагає певного синтаксису, що називається <dfn>for...in</dfn> циклом. Для нашого `users` об'єкту, це може виглядати так:
```js
for (let user in users) {
console.log(user);
}
```
Це б зазначило, що `Alan`, `Jeff`, `Sarah`, і `Ryan` мають кожне значення у власному рядку.
У цьому циклі ми визначили змінну `user` і, як ви можете побачити, цю змінну скидували під час кожної ітерації ключів об'єкта, в міру зациклювання через об’єкт, що призводить до того, що кожне ім'я користувача друкується на консолі.
**ПРИМІТКА:** об'єкти не зберігають впорядкування ключів так, як це роблять масиви. Таким чином, позиція ключа в об'єкті або відносний його порядок є недоречним, коли ми його відсилаємо або отримуємо до нього доступ.
# --instructions--
Ми визначили функцію `countOnline`, яка приймає один аргумент (користувацький об'єкт). Використовуйте <dfn>for...in</dfn> цикл у межах цієї функції, щоб обробити користувацький об'єкт, який перейшов у функцію, і повернути кількість користувачів, чия `online` властивість установлена на `true`. Приклад користувацького об'єкту, який можна передати до `countOnline`, показано нижче. Кожен користувач матиме `online` властивість з обома `true` або `false` значеннями.
```js
{
Alan: {
online: false
},
Jeff: {
online: true
},
Sarah: {
online: false
}
}
```
# --hints--
Для функції `countOnline` слід використовувати `for in` цикл, щоб ітерувати ключі об'єкта, який передається до неї.
```js
assert(
code.match(
/for\s*\(\s*(var|let|const)\s+[a-zA-Z_$]\w*\s+in\s+[a-zA-Z_$]\w*\s*\)/
)
);
```
Функція `countOnline` повинна повернути `1`, коли об'єкт `{ Alan: { online: false }, Jeff: { online: true }, Sarah: { online: false } }` передається до неї
```js
assert(countOnline(usersObj1) === 1);
```
Функція `countOnline` повинна повернути `2`, коли об'єкт `{ Alan: { online: true }, Jeff: { online: false }, Sarah: { online: true } }` передається до неї
```js
assert(countOnline(usersObj2) === 2);
```
Функція `countOnline` повинна повернути `0`, коли об'єкт `{ Alan: { online: false }, Jeff: { online: false }, Sarah: { online: false } }` передається до неї
```js
assert(countOnline(usersObj3) === 0);
```
# --seed--
## --after-user-code--
```js
const usersObj1 = {
Alan: {
online: false
},
Jeff: {
online: true
},
Sarah: {
online: false
}
}
const usersObj2 = {
Alan: {
online: true
},
Jeff: {
online: false
},
Sarah: {
online: true
}
}
const usersObj3 = {
Alan: {
online: false
},
Jeff: {
online: false
},
Sarah: {
online: false
}
}
```
## --seed-contents--
```js
function countOnline(usersObj) {
// Only change code below this line
// Only change code above this line
}
```
# --solutions--
```js
function countOnline(usersObj) {
let online = 0;
for(let user in usersObj){
if(usersObj[user].online) {
online++;
}
}
return online;
}
```

112
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md Normal file
View File

@@ -0,0 +1,112 @@
---
id: 587d7b7d367417b2b2512b1f
title: Змінити масив, збережений в об'єкті
challengeType: 1
forumTopicId: 301163
dashedName: modify-an-array-stored-in-an-object
---
# --description--
Тепер вам відомо про всі основні операції стосовно об'єктів JavaScript. Ви можете додавати, змінювати та видаляти пари ключів і значень, перевіряти, чи існують ключі, і ітерувати усі ключі в об'єкті. Продовжуючи вивчення JavaScript ви познайомитесь з ще більш універсальними програми об'єктів. Крім того, уроки про структури даних, що належать до розділу «Coding Interview Prep» навчальної програми, також містять інформацію про ES6 <dfn>Map</dfn> та <dfn>Set</dfn> об'єкти, які є схожими на звичайні об'єкти, але забезпечують певні додаткові функції. Тепер, коли ви з'ясували, що таке масиви та об'єкти, ви цілком готові до вирішення складніших проблем з допомогою JavaScript!
# --instructions--
Зверніть увагу на об’єкт, який подано в редакторі коду. Об'єкт `user` містить три ключі. Ключ `data` містить п'ять ключів, один з яких містить масив `friends`. З цього можна зрозуміти, наскільки гнучкими є об'єкти як структури даних. Ми почали писати функцію `addFriend`. Завершіть її для того, щоб вона прийняла об'єкт `user` і додала назву аргументу `friend` до масиву, збереженого в `user.data.friends` і повернула цей масив.
# --hints--
Об'єкт `user` повинен мати наступні ключі: `name`, `age` та `data`.
```js
assert('name' in user && 'age' in user && 'data' in user);
```
Функція `addFriend` повинна прийняти об’єкт `user` і рядок `friend` у ролі аргументів, а також додати ще один до масиву `friends` в об'єкті `user`.
```js
assert(
(function () {
let L1 = user.data.friends.length;
addFriend(user, 'Sean');
let L2 = user.data.friends.length;
return L2 === L1 + 1;
})()
);
```
`addFriend(user, "Pete")` повинен повернути `["Sam", "Kira", "Tomo", "Pete"]`.
```js
assert.deepEqual(
(function () {
delete user.data.friends;
user.data.friends = ['Sam', 'Kira', 'Tomo'];
return addFriend(user, 'Pete');
})(),
['Sam', 'Kira', 'Tomo', 'Pete']
);
```
# --seed--
## --seed-contents--
```js
let user = {
name: 'Kenneth',
age: 28,
data: {
username: 'kennethCodesAllDay',
joinDate: 'March 26, 2016',
organization: 'freeCodeCamp',
friends: [
'Sam',
'Kira',
'Tomo'
],
location: {
city: 'San Francisco',
state: 'CA',
country: 'USA'
}
}
};
function addFriend(userObj, friend) {
// Only change code below this line
// Only change code above this line
}
console.log(addFriend(user, 'Pete'));
```
# --solutions--
```js
let user = {
name: 'Kenneth',
age: 28,
data: {
username: 'kennethCodesAllDay',
joinDate: 'March 26, 2016',
organization: 'freeCodeCamp',
friends: [
'Sam',
'Kira',
'Tomo'
],
location: {
city: 'San Francisco',
state: 'CA',
country: 'USA'
}
}
};
function addFriend(userObj, friend) {
userObj.data.friends.push(friend);
return userObj.data.friends;
}
```

101
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md Normal file
View File

@@ -0,0 +1,101 @@
---
id: 587d7b7c367417b2b2512b19
title: Змінити об'єкт, вкладений в інший об'єкт
challengeType: 1
forumTopicId: 301164
dashedName: modify-an-object-nested-within-an-object
---
# --description--
Тепер давайте розглянемо дещо складніший об'єкт. Властивості об'єкта можуть бути вкладені на довільну глибину, а їхні значення можуть бути будь-яким видом даних, що підтримується JavaScript, включно з масивами й навіть іншими об'єктами. Зверніть увагу:
```js
let nestedObject = {
id: 28802695164,
date: 'December 31, 2016',
data: {
totalUsers: 99,
online: 80,
onlineStatus: {
active: 67,
away: 13,
busy: 8
}
}
};
```
`nestedObject` має три властивості: `id` (значення — це число), `date` (значення — це рядок), а `data` (значення — це об'єкт з його вкладеною структурою). Хоча структури можуть швидко ускладнюватися, все одно можна використовувати ті самі позначення, щоб отримати доступ до необхідної інформації. Щоб закріпити значення `10` до властивості `busy`, вкладеної в об'єкт `onlineStatus`, використовується точкова нотація, щоб посилатись на властивість:
```js
nestedObject.data.onlineStatus.busy = 10;
```
# --instructions--
Тут ми окреслили об'єкт `userActivity`, який включає в себе інший вкладений об'єкт. Встановіть значення ключа `online` до `45`.
# --hints--
`userActivity` повинен мати такі властивості: `id`,`date` і`data`.
```js
assert(
'id' in userActivity && 'date' in userActivity && 'data' in userActivity
);
```
`userActivity` має мати `data` ключ, встановлений в об'єкті з `totalUsers` і `online` ключами.
```js
assert('totalUsers' in userActivity.data && 'online' in userActivity.data);
```
Властивість `online`, вкладена в `data` ключі `userActivity` повинен бути встановлений до `45`
```js
assert(userActivity.data.online === 45);
```
Властивість `online` повинна бути встановлена за допомогою точкової нотації або квадратних дужок.
```js
assert.strictEqual(code.search(/online: 45/), -1);
```
# --seed--
## --seed-contents--
```js
let userActivity = {
id: 23894201352,
date: 'January 1, 2017',
data: {
totalUsers: 51,
online: 42
}
};
// Only change code below this line
// Only change code above this line
console.log(userActivity);
```
# --solutions--
```js
let userActivity = {
id: 23894201352,
date: 'January 1, 2017',
data: {
totalUsers: 51,
online: 42
}
};
userActivity.data.online = 45;
```

86
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md Normal file
View File

@@ -0,0 +1,86 @@
---
id: 587d78b2367417b2b2512b0f
title: Видалити елементи з масиву за допомогою функцій pop() і shift()
challengeType: 1
forumTopicId: 301165
dashedName: remove-items-from-an-array-with-pop-and-shift
---
# --description--
Обидві функції `push()` і `unshift()` використовують відповідні методи, які за функціями майже протилежні: `pop()` та `shift()`. Як ви вже, напевне, зрозуміли, `pop()` *видаляє* елемент з кінця масиву, а не додає його, тоді як `shift()` видаляє елемент з початку. Ключова різниця між `pop()` і `shift()` та їх "ріднею", тобто `push()` і `unshift()` полягає в тому, що жоден метод не приймає параметри, а тільки дозволяє масиву змінюватися за допомогою одного елемента одночасно.
Звернімо увагу:
```js
let greetings = ['whats up?', 'hello', 'see ya!'];
greetings.pop();
```
`greetings` отримала б значення `['whats up?', 'hello']`.
```js
greetings.shift();
```
`greetings` отримала б значення `['hello']`.
Ми також можемо повернути значення видаленого елемента за допомогою будь-якого з цих методів:
```js
let popped = greetings.pop();
```
`greetings` отримала б значення `[]`, а `popped` отримала б значення `hello`.
# --instructions--
Ми визначили функцію, `popShift`, яка приймає масив як аргумент і повертає новий масив. Змініть функцію, використовуючи `pop()` і `shift()`, щоб видалити перший та останній елементи масиву аргументів і призначити видалені елементи до їх відповідних змінних, щоб повернутий масив містив їхні значення.
# --hints--
`popShift(["challenge", "is", "not", "complete"])` має повернути `["challenge", "complete"]`
```js
assert.deepEqual(popShift(['challenge', 'is', 'not', 'complete']), [
'challenge',
'complete'
]);
```
Функція `popShift` повинна використовувати метод `pop()`
```js
assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1);
```
Функція `popShift` повинна використовувати метод `shift()`
```js
assert.notStrictEqual(popShift.toString().search(/\.shift\(/), -1);
```
# --seed--
## --seed-contents--
```js
function popShift(arr) {
let popped; // Change this line
let shifted; // Change this line
return [shifted, popped];
}
console.log(popShift(['challenge', 'is', 'not', 'complete']));
```
# --solutions--
```js
function popShift(arr) {
let popped = arr.pop(); // Change this line
let shifted = arr.shift(); // Change this line
return [shifted, popped];
}
```

87
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md Normal file
View File

@@ -0,0 +1,87 @@
---
id: 587d78b2367417b2b2512b10
title: Видалити елементи за допомогою функції splice()
challengeType: 1
forumTopicId: 301166
dashedName: remove-items-using-splice
---
# --description--
Що ж, ми дізналися, як видалити елементи з початку і кінця масиву, використовуючи `shift()` і `pop()`, але що робити, якщо ми хочемо прибрати елемент десь зі середини? Або видалити декілька елементів одразу? Якраз тут нам на допомогу може прийти `splice()`. `splice()` дозволяє нам зробити ось що: **видалити будь-яку кількість послідовних елементів** будь-де в масиві.
`splice()` може прийняти до трьох параметрів, але зараз ми зосередимося на перших двох. Перші два параметри `splice()` — це цілі числа, які позначають індекси або позиції масиву, яким викликається `splice()`. Пам'ятайте, якщо масиви є *zero-indexed*, ми б використовували `0`, щоб зазначити перший елемент масиву. Перший параметр функції `splice()` позначає індекс в масиві, з якого починають видаляти елементи, у той час як другий параметр зазначає кількість елементів, необхідних для видалення. Наприклад:
```js
let array = ['today', 'was', 'not', 'so', 'great'];
array.splice(2, 2);
```
Ось тут видаляємо 2 елементи, починаючи з третього елемента (за другим індексом). `array` отримала б значення `['today', 'was', 'great']`.
`splice()` не лише змінює масив, на який вона викликається, але й повертає новий масив, що містить значення видалених елементів:
```js
let array = ['I', 'am', 'feeling', 'really', 'happy'];
let newArray = array.splice(3, 2);
```
`newArray` має значення `['really', 'happy']`.
# --instructions--
Ми ініціалізували масив `arr`. Використовуйте `splice()`, щоб видалити елементи з `arr`, для того щоб він містив виключно елементи, які разом складають значення `10`.
# --hints--
Не потрібно змінювати вихідний рядок `const arr = [2, 4, 5, 1, 7, 5, 2, 1];`.
```js
assert(
__helpers.removeWhiteSpace(code).match(/constarr=\[2,4,5,1,7,5,2,1\];?/)
);
```
`arr` повинен містити лише елементи, які разом складають значення до `10`.
```js
assert.strictEqual(
arr.reduce((a, b) => a + b),
10
);
```
Ваш код повинен використовувати метод `splice()` у `arr`.
```js
assert(__helpers.removeWhiteSpace(code).match(/arr\.splice\(/));
```
Функція splice може лише видаляти елементи з `arr`, а не додавати їх до `arr`.
```js
assert(
!__helpers.removeWhiteSpace(code).match(/arr\.splice\(\d+,\d+,\d+.*\)/g)
);
```
# --seed--
## --seed-contents--
```js
const arr = [2, 4, 5, 1, 7, 5, 2, 1];
// Only change code below this line
// Only change code above this line
console.log(arr);
```
# --solutions--
```js
const arr = [2, 4, 5, 1, 7, 5, 2, 1];
arr.splice(1, 4);
```

95
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md Normal file
View File

@@ -0,0 +1,95 @@
---
id: 587d7b7e367417b2b2512b20
title: Використання масиву для зберігання зібраних даних
challengeType: 1
forumTopicId: 301167
dashedName: use-an-array-to-store-a-collection-of-data
---
# --description--
Нижче наведено приклад найпростішої реалізації структури масиву даних. Його називають <dfn>one-dimensional array</dfn>, що означає, що він має лише один рівень або що він не має жодних інших вкладених масивів. Зверніть увагу, що в ньому містяться <dfn>booleans</dfn>, <dfn>strings</dfn> і <dfn>numbers</dfn> серед інших дійсних типів даних JavaScript:
```js
let simpleArray = ['one', 2, 'three', true, false, undefined, null];
console.log(simpleArray.length);
```
Виклик `console.log` відображає `7`.
Усі масиви мають властивість довжини, до якої, як згадується вище, дуже легко можна отримати доступ за допомогою синтаксису `Array.length`. Складнішу реалізацію масиву можна побачити нижче. Це відомий <dfn>multi-dimensional array</dfn>, або масив що містить інші масиви. Зверніть увагу, що цей масив також включає JavaScript <dfn>objects</dfn>, які ми ретельно вивчатимемо в наступному розділі, але поки вам потрібно знати тільки те, що масиви також здатні зберігати складні об'єкти.
```js
let complexArray = [
[
{
one: 1,
two: 2
},
{
three: 3,
four: 4
}
],
[
{
a: "a",
b: "b"
},
{
c: "c",
d: "d"
}
]
];
```
# --instructions--
Ми визначили змінну з назвою `yourArray`. Виконайте інструкцію, призначаючи масив принаймні з 5 елементів у довжину до змінної `yourArray`. Ваш масив повинен містити щонайменше по-одному <dfn>string</dfn>, <dfn>number</dfn> і <dfn>boolean</dfn>.
# --hints--
`yourArray` повинна бути масивом.
```js
assert.strictEqual(Array.isArray(yourArray), true);
```
`yourArray` повинна складати щонайменше з 5 елементів в довжину.
```js
assert.isAtLeast(yourArray.length, 5);
```
`yourArray` повинна містити щонайменше одне `boolean`.
```js
assert(yourArray.filter((el) => typeof el === 'boolean').length >= 1);
```
`yourArray` повинна містити щонайменше одне `number`.
```js
assert(yourArray.filter((el) => typeof el === 'number').length >= 1);
```
`yourArray` повинна містити щонайменше один `string`.
```js
assert(yourArray.filter((el) => typeof el === 'string').length >= 1);
```
# --seed--
## --seed-contents--
```js
let yourArray; // Change this line
```
# --solutions--
```js
let yourArray = ['a string', 100, true, ['one', 2], 'another string'];
```

86
curriculum/challenges/ukrainian/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md Normal file
View File

@@ -0,0 +1,86 @@
---
id: 587d7b7c367417b2b2512b1b
title: Використати ключове слово delete для видалення властивостей об'єкта
challengeType: 1
forumTopicId: 301168
dashedName: use-the-delete-keyword-to-remove-object-properties
---
# --description--
Тепер вам відомо, що таке об'єкти, а також їхні основні функції і переваги. Коротше кажучи, вони — бази даних "ключ-значення", які забезпечують гнучкий та інтуїтивно зрозумілий спосіб структурування даних, ***і***, вони сприяють зменшенню часу пошуку. У решті цих завдань ми опишемо кілька типових операцій, які ви можете здійснити стосовно об'єктів, щоб вам було зручно застосовувати такі корисні структури даних у ваших програмах.
У попередніх завданнях ми як додавали пари "ключ-значення" в об'єкт, так і змінювали їх. Таким чином, ми зрозуміємо, як ми можемо *видалити* пару "ключ-значення" з об'єкта.
Повернімося до нашого прикладу об'єкту `foods` востаннє. Якщо ми хочемо видалити ключ `apples`, ми можемо зробити це за допомогою ключового слова `delete` наступним чином:
```js
delete foods.apples;
```
# --instructions--
Використайте це ключове слово для видалення `oranges`, `plums` і `strawberries` ключів з об'єкту `foods`.
# --hints--
Об'єкт `foods` має включати тільки три ключі: `apples`, `grapes` і `bananas`.
```js
assert(
!foods.hasOwnProperty('oranges') &&
!foods.hasOwnProperty('plums') &&
!foods.hasOwnProperty('strawberries') &&
Object.keys(foods).length === 3
);
```
Ключі `oranges`, `plums` і `strawberries` необхідно видалити, використовуючи `delete`.
```js
assert(
code.search(/oranges:/) !== -1 &&
code.search(/plums:/) !== -1 &&
code.search(/strawberries:/) !== -1
);
```
# --seed--
## --seed-contents--
```js
let foods = {
apples: 25,
oranges: 32,
plums: 28,
bananas: 13,
grapes: 35,
strawberries: 27
};
// Only change code below this line
// Only change code above this line
console.log(foods);
```
# --solutions--
```js
let foods = {
apples: 25,
oranges: 32,
plums: 28,
bananas: 13,
grapes: 35,
strawberries: 27
};
delete foods.oranges;
delete foods.plums;
delete foods.strawberries;
console.log(foods);
```