Merge with upstream: Translate added text

Author: dolgachio

1-js/04-object-basics/09-object-toprimitive/article.md

@@ -64,7 +64,7 @@ JavaScript не дозволяє налаштувати, як працюють 
     let greater = user1 > user2;
     ```
 
-    Most built-in mathematical functions also include such conversion.
+    Більшість вбудованих математичних функцій також включають таке перетворення.
 
 `"default"`
 : Виникає в рідкісних випадках, коли оператор "не впевнений", який тип очікується.

1-js/05-data-types/04-array/article.md

@@ -92,38 +92,38 @@ let fruits = [
 Кома в кінці спрощує процес додавання/видалення елементів, тому що всі рядки стають однотипними.
 ````
 
-## Get last elements with "at"
+## Отримати останні елементи за допомогою "at"
 
 [recent browser="new"]
 
-Let's say we want a last element of the array.
+Скажімо, нам потрібен останній елемент масиву.
 
-Some programming languages allow to use negative indexes for the same purpose, like `fruits[-1]`.
+Деякі мови програмування дозволяють використовувати негативні індекси з цією ж метою, наприклад, `fruits[-1]`.
 
-Although, in JavaScript it won't work. The result will be `undefined`, because the index in square brackets is treated literally.
+Хоча в JavaScript це не працюватиме. Результат буде `undefined`, оскільки індекс у квадратних дужках трактується буквально.
 
-We can explicitly calculate the last element index and then access it: `fruits[fruits.length - 1]`.
+Ми можемо явно обчислити індекс останнього елемента, а потім отримати до нього доступ: `fruits[fruits.length - 1]`.
 
 ```js run
 let fruits = ["Apple", "Orange", "Plum"];
 
 alert( fruits[fruits.length-1] ); // Plum
 ```
 
-A bit cumbersome, isn't it? We need to write the variable name twice.
+Трохи громіздко, чи не так? Нам потрібно двічі написати ім’я змінної.
 
-Luckily, there's a shorter syntax: `fruits.at(-1)`:
+На щастя, є коротший синтаксис: `fruits.at(-1)`:
 
 ```js run
 let fruits = ["Apple", "Orange", "Plum"];
 
-// same as fruits[fruits.length-1]
+// те ж саме що й fruits[fruits.length-1]
 alert( fruits.at(-1) ); // Plum
 ```
 
-In other words, `arr.at(i)`:
-- is exactly the same as `arr[i]`, if `i >= 0`.
-- for negative values of `i`, it steps back from the end of the array.
+Іншими словами, `arr.at(i)`:
+- те ж саме що й `arr[i]`, якщо `i >= 0`.
+- для негативних значень `i` він шукає елемент відступаючи від кінця масиву.
 
 ## Методи pop/push, shift/unshift
 
@@ -170,7 +170,7 @@ In other words, `arr.at(i)`:
     alert( fruits ); // Apple, Orange
     ```
 
-    Both `fruits.pop()` and `fruits.at(-1)` return the last element of the array, but `fruits.pop()` also modifies the array by removing it.
+    І `fruits.pop()`, і `fruits.at(-1)` повертають останній елемент масиву, але `fruits.pop()` також змінює масив, видаляючи його.
 
 `push`
 : Додає елемент в кінець масиву:

2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md

@@ -1,50 +1,50 @@
-The console output is: 1 7 3 5 2 6 4.
+У консолі ми побачимо: 1 7 3 5 2 6 4.
 
-The task is quite simple, we just need to know how microtask and macrotask queues work.
+Завдання досить просте, нам потрібно лише знати, як працюють черги мікрозадач і макрозадач.
 
-Let's see what's going on, step by step.
+Подивимося, що відбувається, крок за кроком.
 
 ```js
 console.log(1);
-// The first line executes immediately, it outputs `1`.
-// Macrotask and microtask queues are empty, as of now.
+// Перший рядок виконується негайно і виводить `1`.
+// На даний момент черги макрозадач і мікрозадач порожні.
 
 setTimeout(() => console.log(2));
-// `setTimeout` appends the callback to the macrotask queue.
-// - macrotask queue content:
+// `setTimeout` додає зворотний виклик функції до черги макрозадач. 
+// - вміст черги макрозадач:
 //   `console.log(2)`
 
 Promise.resolve().then(() => console.log(3));
-// The callback is appended to the microtask queue.
-// - microtask queue content:
+// Зворотний виклик функції додається до черги мікрозадач.
+// - вміст черги мікрозадач:
 //   `console.log(3)`
 
 Promise.resolve().then(() => setTimeout(() => console.log(4)));
-// The callback with `setTimeout(...4)` is appended to microtasks
-// - microtask queue content:
+// Зворотний виклик функції із `setTimeout(...4)` додається до мікрозадач
+// - вміст черги мікрозадач:
 //   `console.log(3); setTimeout(...4)`
 
 Promise.resolve().then(() => console.log(5));
-// The callback is appended to the microtask queue
-// - microtask queue content:
+// Зворотний виклик додається до черги мікрозадач
+// - вміст черги мікрозадач:
 //   `console.log(3); setTimeout(...4); console.log(5)`
 
 setTimeout(() => console.log(6));
-// `setTimeout` appends the callback to macrotasks
-// - macrotask queue content:
+// `setTimeout` додає зворотний виклик функції до макрозадач
+// - вміст черги макрозадач:
 //   `console.log(2); console.log(6)`
 
 console.log(7);
-// Outputs 7 immediately.
+// Негайно виводить 7.
 ```
 
-To summarize,
+Підведемо підсумки,
 
-1. Numbers `1` и `7` show up immediately, because simple `console.log` calls don't use any queues.
-2. Then, after the main code flow is finished, the microtask queue runs.
-    - It has commands: `console.log(3); setTimeout(...4); console.log(5)`.
-    - Numbers `3` и `5` show up, while `setTimeout(() => console.log(4))` adds the `console.log(4)` call to the end of the macrotask queue.
-    - The macrotask queue is now: `console.log(2); console.log(6); console.log(4)`.
-3. After the microtask queue becomes empty, the macrotask queue executes. It outputs `2`, `6`, `4`.
+1. Числа `1` і `7` з’являються відразу, тому що прості виклики `console.log` не використовують жодних черг.
+2. Потім, після завершення основного потоку коду, запускається черга мікрозадач.
+    - Він містить команди: `console.log(3); setTimeout(...4); console.log(5)`.
+    - З’являються числа `3` і `5`, а `setTimeout(() => console.log(4))` додає виклик `console.log(4)` в кінець черги макрозадач.
+    - Черга макрозадач тепер така: `console.log(2); console.log(6); console.log(4)`.
+3. Після того як черга мікрозадач стає порожньою, виконується черга макрозадач. І він виводить `2`, `6`, `4`.
 
-Finally, we have the output: `1 7 3 5 2 6 4`.
+Нарешті, маємо у консолі: `1 7 3 5 2 6 4`.

2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/task.md

@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# What will be the output of this code?
+# Що буде результатом цього коду?
 
 ```js
 console.log(1);

4-binary/03-blob/article.md

@@ -221,31 +221,31 @@ const bufferPromise = await blob.arrayBuffer();
 blob.arrayBuffer().then(buffer => /* process the ArrayBuffer */);
 ```
 
-## From Blob to stream
+## Від Blob до потоку
 
-When we read and write to a blob of more than `2 GB`, the use of `arrayBuffer` becomes more memory intensive for us. At this point, we can directly convert the blob to a stream.
+Коли ми читаємо та пишемо в blob дані розміром понад `2 ГБ`, використання `arrayBuffer` стає більш інтенсивним для нас. На цьому етапі ми можемо безпосередньо перетворити blob на потік.
 
-A stream is a special object that allows to read from it (or write into it) portion by portion. It's outside of our scope here, but here's an example, and you can read more at <https://developer.mozilla.org/en-US/docs/Web/API/Streams_API>. Streams are convenient for data that is suitable for processing piece-by-piece.
+Потік -- це спеціальний об’єкт, який дозволяє читати з нього (або записувати в нього) частина за частиною. Це виходить за рамки цієї статті, але ось приклад, і ви можете прочитати більше на сторінці <https://developer.mozilla.org/en-US/docs/Web/API/Streams_API>. Потоки зручні для даних, які придатні для обробки частинами.
 
-The `Blob` interface's `stream()` method returns a `ReadableStream` which upon reading returns the data contained within the `Blob`.
+Метод `stream()` інтерфейсу `Blob` повертає `ReadableStream`, який під час читання повертає дані, що містяться в `Blob`.
 
-Then we can read from it, like this:
+Прочитати з нього ми можемо, наприклад, ось так:
 
 ```js
-// get readableStream from blob
+// отримати readableStream з blob
 const readableStream = blob.stream();
 const stream = readableStream.getReader();
 
 while (true) {
-  // for each iteration: data is the next blob fragment
+  // для кожної ітерації: дані є наступним фрагментом(частиною) blob
   let { done, data } = await stream.read();
   if (done) {
-    // no more data in the stream
+    // більше немає даних у потоці
     console.log('all blob processed.');
     break;
   }
 
-   // do something with the data portion we've just read from the blob
+   // зробити щось із частиною даних, яку ми щойно прочитали з blob
   console.log(data);
 }
 ```