add uk 96-105

uk-UA/README.md

@@ -3050,7 +3050,7 @@ console.log(nums(1, 2));
 
 #### Відповідь: B
 
-У JavaScript нам _не потрібно_ явно писати крапку з комою (`;`), однак механізм JavaScript все одно додає їх після інструкцій. Це називається **Автоматична вставка крапки з комою**. інструкції можуть бути, наприклад, змінні або ключові слова, як-от `throw`, `return`, `break` тощо.
+У JavaScript нам _не потрібно_ явно писати крапку з комою (`;`), однак рушій JavaScript все одно додає їх після інструкцій. Це називається **Автоматична вставка крапки з комою**. інструкції можуть бути, наприклад, змінні або ключові слова, як-от `throw`, `return`, `break` тощо.
 
 Тут ми написали оператор `return` і ще одне значення `a + b` у _новому рядку_. Однак, оскільки це новий рядок, рушій не знає, що це насправді значення, яке ми хотіли повернути. Замість цього він автоматично додає крапку з комою після `return`. Ми можемо побачити це як:
 
@@ -3063,3 +3063,346 @@ a + b;
 
 </p>
 </details>
+
+---
+
+###### 96. Що буде на виході?
+
+```javascript
+class Person {
+  constructor() {
+    this.name = 'Lydia';
+  }
+}
+
+Person = class AnotherPerson {
+  constructor() {
+    this.name = 'Sarah';
+  }
+};
+
+const member = new Person();
+console.log(member.name);
+```
+
+- A: `"Lydia"`
+- B: `"Sarah"`
+- C: `Error: cannot redeclare Person`
+- D: `SyntaxError`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: B
+
+Ми можемо встановити класи рівними іншим класам/конструкторам функцій. У цьому випадку ми встановлюємо `Person` рівним `AnotherPerson`. Властивість name цього конструктора – `Sarah`, тому властивість name нового екземпляра `Person` теж `"Sarah"`.
+
+</p>
+</details>
+
+---
+
+###### 97. Що буде на виході?
+
+```javascript
+const info = {
+  [Symbol('a')]: 'b',
+};
+
+console.log(info);
+console.log(Object.keys(info));
+```
+
+- A: `{Symbol('a'): 'b'}` та `["{Symbol('a')"]`
+- B: `{}` та `[]`
+- C: `{ a: "b" }` та `["a"]`
+- D: `{Symbol('a'): 'b'}` та `[]`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: D
+
+Символ не є _перелічуваним_. Метод Object.keys повертає всі ключі об’єкта, які _перелічуються_. Символ буде невидимим, і буде повернуто порожній масив. Під час логування всього об’єкта всі властивості будуть видимі, навіть ті, що не перелічуються.
+
+Це одна з багатьох властивостей символу: окрім представлення цілком унікального значення (що запобігає випадковій колізії імен об’єктів, наприклад, під час роботи з двома бібліотеками, які хочуть додати властивості до того самого об’єкта), ми також можемо "приховати" властивості об’єктів таким чином (хоча не повністю. Ми все ще можемо отримати доступ до символів за допомогою методу `Object.getOwnPropertySymbols()`).
+
+</p>
+</details>
+
+---
+
+###### 98. Що буде на виході?
+
+```javascript
+const getList = ([x, ...y]) => [x, y]
+const getUser = user => { name: user.name, age: user.age }
+
+const list = [1, 2, 3, 4]
+const user = { name: "Lydia", age: 21 }
+
+console.log(getList(list))
+console.log(getUser(user))
+```
+
+- A: `[1, [2, 3, 4]]` та `SyntaxError`
+- B: `[1, [2, 3, 4]]` та `{ name: "Lydia", age: 21 }`
+- C: `[1, 2, 3, 4]` та `{ name: "Lydia", age: 21 }`
+- D: `Error` та `{ name: "Lydia", age: 21 }`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: A
+
+Функція `getList` отримує масив як аргумент. Між дужками функції `getList` ми одразу деструктуруємо цей масив. Ви можете побачити це як:
+
+`[x, ...y] = [1, 2, 3, 4]`
+
+За допомогою параметра rest `...y` ми поміщаємо всі "залишкові" аргументи в масив. Решта аргументів у цьому випадку – це `2`, `3` та `4`. Значення `y` є масивом, що містить усі інші параметри. У цьому випадку значення `x` дорівнює `1`, тому, коли ми логуємо `[x, y]`, отримуємо `[1, [2, 3, 4]]`.
+
+Функція `getUser` отримує об’єкт. З стрілковими функціями нам не _потрібно_ писати фігурні дужки, якщо ми повертаємо лише одне значення. Однак, якщо ми хочемо миттєво повернути _об’єкт_ зі стрілкової функції, ми повинні записати його в круглих дужках, інакше все, що знаходиться між двома дужками, буде інтерпретовано як інструкція блоку. У цьому випадку код у фігурних дужках не є дійсним кодом JavaScript, тому викидається `SyntaxError`.
+
+Наступна функція повернула б об’єкт:
+
+`const getUser = user => ({ name: user.name, age: user.age })`
+
+</p>
+</details>
+
+---
+
+###### 99. Що буде на виході?
+
+```javascript
+const name = 'Lydia';
+
+console.log(name());
+```
+
+- A: `SyntaxError`
+- B: `ReferenceError`
+- C: `TypeError`
+- D: `undefined`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: C
+
+Змінна `name` містить значення рядка, який не є функцією, тому її не можна викликати.
+
+Помилки TypeErrors викидаються, коли значення не відповідає очікуваному типу. JavaScript очікував, що `name` буде функцією, оскільки ми намагаємося її викликати. Однак це був рядок, тому викидається TypeError: name is not a function!
+
+Помилки SyntaxErrors виникають, коли ми написали щось, що не є дійсним JavaScript, наприклад, коли ми написали слово `return` як `retrun`.
+
+Помилки ReferenceErrors викидаються, коли JavaScript не може знайти посилання на значення, до якого ми намагаємося отримати доступ.
+
+</p>
+</details>
+
+---
+
+###### 100. Яке значення output?
+
+```javascript
+// 🎉✨ This is my 100th question! ✨🎉
+
+const output = `${[] && 'Im'}possible!
+You should${'' && `n't`} see a therapist after so much JavaScript lol`;
+```
+
+- A: `possible! You should see a therapist after so much JavaScript lol`
+- B: `Impossible! You should see a therapist after so much JavaScript lol`
+- C: `possible! You shouldn't see a therapist after so much JavaScript lol`
+- D: `Impossible! You shouldn't see a therapist after so much JavaScript lol`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: B
+
+`[]` є значенням true. За допомогою оператора `&&` буде повернено значення справа, якщо значення ліворуч є true. У цьому випадку ліве значення `[]` є true, тому повертається `"Im"`.
+
+`""` є значенням false. Якщо ліве значення є false, нічого не повертається. `n't` не повертається.
+
+</p>
+</details>
+
+---
+
+###### 101. Що буде на виході?
+
+```javascript
+const one = false || {} || null;
+const two = null || false || '';
+const three = [] || 0 || true;
+
+console.log(one, two, three);
+```
+
+- A: `false` `null` `[]`
+- B: `null` `""` `true`
+- C: `{}` `""` `[]`
+- D: `null` `null` `true`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: C
+
+За допомогою оператора `||` ми можемо повернути перший правдивий операнд. Якщо всі значення хибні, повертається останній операнд.
+
+`(false || {} || null)`: порожній об’єкт `{}` є значенням true. Це перше (і єдине) значення true, яке повертається. `one` дорівнює `{}`.
+
+`(null || false || "")`: усі операнди є значеннями false. Це означає, що повертається останній операнд `""`. `two` дорівнює `""`.
+
+`([] || 0 || "")`: порожній масив `[]` є значенням true. Це перше значення true, яке повертається. `three` дорівнює `[]`.
+
+</p>
+</details>
+
+---
+
+###### 102. Що буде на виході?
+
+```javascript
+const myPromise = () => Promise.resolve('I have resolved!');
+
+function firstFunction() {
+  myPromise().then(res => console.log(res));
+  console.log('second');
+}
+
+async function secondFunction() {
+  console.log(await myPromise());
+  console.log('second');
+}
+
+firstFunction();
+secondFunction();
+```
+
+- A: `I have resolved!`, `second` та `I have resolved!`, `second`
+- B: `second`, `I have resolved!` та `second`, `I have resolved!`
+- C: `I have resolved!`, `second` та `second`, `I have resolved!`
+- D: `second`, `I have resolved!` та `I have resolved!`, `second`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: D
+
+З промісами ми говоримо _я хочу виконати цю функцію, але поки що я відкладу її, поки вона працює, оскільки це може зайняти деякий час. Лише коли певне значення resolved (або rejected) і коли стек викликів порожній, я хочу використовувати це значення._
+
+Ми можемо отримати це значення за допомогою ключового слова `.then` і `await` у функції `async`. Хоча ми можемо отримати значення проміса як за допомогою `.then`, так і `await`, вони працюють дещо інакше.
+
+У `firstFunction` ми (начебто) відклали функцію myPromise, поки вона працювала, але продовжили виконувати інший код, у цьому випадку `console.log('second')`. Потім функція resolved з рядком `I have resolved`, який залогувався після того, як стек викликів спорожнів.
+
+За допомогою ключового слова await у `secondFunction` ми буквально призупиняємо виконання асинхронної функції, доки значення не буде resolved перед переходом до наступного рядка.
+
+Це означає, що вона чекала, поки `myPromise` resolved зі значенням `I have resolved`, і лише коли це сталося, ми перейшли до наступного рядка: `second` залогувався.
+
+</p>
+</details>
+
+---
+
+###### 103. Що буде на виході?
+
+```javascript
+const set = new Set();
+
+set.add(1);
+set.add('Lydia');
+set.add({ name: 'Lydia' });
+
+for (let item of set) {
+  console.log(item + 2);
+}
+```
+
+- A: `3`, `NaN`, `NaN`
+- B: `3`, `7`, `NaN`
+- C: `3`, `Lydia2`, `[object Object]2`
+- D: `"12"`, `Lydia2`, `[object Object]2`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: C
+
+Оператор `+` використовується не тільки для додавання числових значень, але ми також можемо використовувати його для об'єднання рядків. Щоразу, коли рушій JavaScript бачить, що одне чи кілька значень не є числом, він перетворює число в рядок.
+
+Перше це число `1`. `1 + 2`повертає число 3.
+
+Однак другий — рядок `"Lydia"`. `"Lydia"` є рядком, а `2` — числом: `2` перетворюється на рядок. `"Lydia"` і `"2"` конкатенуються, що призводить до рядка `"Lydia2"`.
+
+`{ name: "Lydia" }` є об’єктом. Ані число, ані об’єкт не є рядком, тому він об’єднує обидва. Кожного разу, коли ми перетворюємо звичайний об’єкт у рядок, він перетворюється на `"[object Object]"`. `"[object Object]"` об'єднаний з `"2"` стає `"[object Object]2"`.
+
+</p>
+</details>
+
+---
+
+###### 104. Яким буде його значення?
+
+```javascript
+Promise.resolve(5);
+```
+
+- A: `5`
+- B: `Promise {<pending>: 5}`
+- C: `Promise {<fulfilled>: 5}`
+- D: `Error`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: C
+
+Ми можемо передати в `Promise.resolve` значення будь-якого типу, проміс чи не проміс. Сам метод повертає проміс з resolved значенням (`<fulfilled>`). Якщо ми передаємо звичайну функцію, це буде resolved проміс зі звичайним значенням. Якщо ми передаємо проміс, це буде resolved проміс з resolved значенням цього переданого проміса.
+
+У цьому випадку ми просто передали числове значення `5`. Він повертає resolved проміс зі значенням `5`.
+
+</p>
+</details>
+
+---
+
+###### 105. Що буде на виході?
+
+```javascript
+function compareMembers(person1, person2 = person) {
+  if (person1 !== person2) {
+    console.log('Not the same!');
+  } else {
+    console.log('They are the same!');
+  }
+}
+
+const person = { name: 'Lydia' };
+
+compareMembers(person);
+```
+
+- A: `Not the same!`
+- B: `They are the same!`
+- C: `ReferenceError`
+- D: `SyntaxError`
+
+<details><summary><b>Відповідь</b></summary>
+<p>
+
+#### Відповідь: B
+
+Об'єкти передаються за посиланням. Коли ми перевіряємо об’єкти на точну рівність (`===`), ми порівнюємо їхні посилання.
+
+Ми встановили значення за замовчуванням для `person2` рівним об’єкту `person` і передали об’єкт `person` як значення для `person1`.
+
+Це означає, що обидва значення мають посилання на одне й те саме місце в пам’яті, отже, вони рівні.
+
+Блок коду в операторі `else` виконується і `They are the same!` логується.
+
+</p>
+</details>