javascript-tutorial · tarasyyyk · Oct 3, 2020 · Sep 18, 2020 · Oct 3, 2020
diff --git a/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md b/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md
@@ -12,10 +12,10 @@ null === +"\n0\n" → false
 
 Ось чому такі результати:
 
-1. Очевидно, 5 більше за 4. true.
+1. Очевидно, 5 більше за 4. `true`.
 2. Посимвольне порівняння, тому `false`. `"а"` менше за `"я"`.
 3. Знову посимвольне порівняння. Перший символ рядка `"2"` більший за перший символ другого рядка — `"1"`.
-4. Спеціальний випадок. Значення `null` і `undefined` рівні під час не строгого порівняння.
+4. Спеціальний випадок. Значення `null` і `undefined` рівні лише один одному під час нестрогого порівняння.
 5. Строге порівняння різних типів, тому `false`.
-6. Аналогічно, як в кроці `(4)`, `null` рівне лише `undefined`.
+6. Аналогічно, як в кроці `(4)`, `null` дорівнює лише `undefined`.
 7. Строге порівняння різних типів.
diff --git a/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md b/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Оператори порівняння
 
-Який буде результат порівняння цих виразів?
+Який буде результат цих виразів?
 
 ```js no-beautify
 5 > 4

diff --git a/1-js/02-first-steps/09-comparison/article.md b/1-js/02-first-steps/09-comparison/article.md
@@ -1,24 +1,24 @@
 # Оператори порівняння
 
-Багато з операторів порівняння нам відомі з математики:
+Багато з операторів порівняння нам відомі з математики.
 
 В JavaScript вони записуються ось так:
 
 - Більше/менше: <code>a &gt; b</code>, <code>a &lt; b</code>.
-- Більше/менше або рівне: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
-- Рівне: `a == b`, зверніть увагу, для порівняння потрібно використовувати два знаки рівності `==`. Один знак рівності `a = b` означало б присвоєння.
-- Не рівне. В математиці позначається символом <code>&ne;</code>, проте в JavaScript записується як <code>a != b</code>.
+- Більше/менше або дорівнює: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
+- Дорівнює: `a == b`. Зверніть увагу, для порівняння потрібно використовувати два знаки рівності `==`. Один знак рівності `a = b` означав б присвоєння.
+- Не дорівнює. В математиці позначається символом <code>&ne;</code>, проте в JavaScript записується як <code>a != b</code>.
 
-В цьому розділі ми вивчимо про різні типи порівнянь, як JavaScript їх виконує та розглянемо важливі особливості.
+В цьому розділі ми вивчимо різні типи порівнянь, узнаємо, як JavaScript їх виконує, та розглянемо важливі особливості.
 
-В кінці ви знайдете корисні поради, як уникати специфічні "примхи JavaScript".
+В кінці ви знайдете корисні поради, як уникати специфічних "примх" JavaScript.
 
 ## Результат порівняння має логічний тип
 
 Всі оператори порівняння повертають значення логічного типу:
 
-- `true` -- означає "так", "правильно" або "правда".
-- `false` -- означає "ні", "неправильно" або "не правда".
+- `true` -- означає "так", "правильно" або "істина".
+- `false` -- означає "ні", "неправильно" або "хибність".
 
 Наприклад:
 
@@ -39,14 +39,14 @@ alert( result ); // true
 
 Щоб визначити, чи один рядок більший за інший, JavaScript використовує так званий "алфавітний" або "лексикографічний" порядок.
 
-Іншими словами, рядки порівнюються посимвольно.
+Інакше кажучи, рядки порівнюються посимвольно.
 
 Наприклад:
 
 ```js run
 alert( 'Я' > 'А' ); // true
-alert( 'Кіт' > 'Код' ); // true
-alert( 'Кома' > 'Комар' ); // false
+alert( 'Соки' > 'Сода' ); // true
+alert( 'Комар' > 'Кома' ); // true
 ```
 
 Алгоритм порівняння рядків досить простий:
@@ -57,16 +57,16 @@ alert( 'Кома' > 'Комар' ); // false
 4. Порівняння продовжується до того часу, доки не закінчиться один з рядків.
 5. Якщо два рядки закінчуються одночасно, то вони рівні. Інакше, довший рядок вважатиметься більшим.
 
-В прикладах вище, порівняння `'Я' > 'А'` завершиться на першому кроці, тоді як `"Кіт"` і `"Код"` будуть порівнюватися посимвольно:
+В прикладах вище, порівняння `'Я' > 'А'` завершиться на першому кроці, тоді як `'Соки'` і `'Сода'` будуть порівнюватися посимвольно:
 
-1. `К` рівне `К`.
-2. `і` більше за `о`.
-3. На другому кроці порівнювання закінчується. Перший рядок більший.
+1. `С` дорівнює `С`.
+2. `о` дорівнює `о`.
+3. `к` більше ніж `д`. На цьому кроці порівнювання закінчується. Перший рядок більший.
 
 ```smart header="Використовується кодування Unicode, а не справжній алфавіт"
 Такий алгоритм порівняння схожий на алгоритм сортування, який використовується в словниках і телефонних довідниках, проте вони не зовсім однакові.
 
-Наприклад, в JavaScript має значення регістр символів. Велика буква `"А"` не рівна маленькій `"а"`. Але яка з них більше? Маленька буква `"а"`. Чому? Тому що маленькі букви мають більший код у внутрішній таблиці кодування, яку використовує JavaScript (Unicode). Ми розглянемо це детальніше в розділі <info:string>.
+Наприклад, в JavaScript має значення регістр символів. Велика буква `"А"` не рівна маленькій `"а"`. Але яка з них більше? Маленька буква `"а"`. Чому? Тому що маленькі букви мають більший код у внутрішній таблиці кодування, яку використовує JavaScript (Unicode). Ми розглянемо особливості і наслідки цього кодування в розділі <info:string>.
 ```
 
 ## Порівняння різних типів
@@ -107,7 +107,7 @@ alert( Boolean(b) ); // true
 alert(a == b); // true!
 ```
 
-З точки зору JavaScript, результат очікуваний. Порівняння перетворює значення на числа (тому `"0"` стає `0`), тоді як явне перетворення `Boolean` використовує інший набір правил.
+З погляду JavaScript, результат очікуваний. Порівняння перетворює значення на числа (тому `"0"` стає `0`), тоді як явне перетворення за допомогою `Boolean` використовує інший набір правил.
 ````
 
 ## Строге порівняння
@@ -146,14 +146,14 @@ alert( 0 === false ); // false, тому що порівнюються різн
 
 Поведінка `null` і `undefined` під час порівняння з іншими значеннями — особливе:
 
-Під час строгого порівняння `===`
+При строгому порівнянні `===`
 : Ці значення різні, тому що різні їхні типи.
 
     ```js run
     alert( null === undefined ); // false
     ```
 
-При не строгому порівнянні `==`
+При нестрогому порівнянні `==`
 : Ці значення рівні. Водночас ці значення не рівні значенням інших типів. Це спеціальне правило мови.
 
     ```js run
@@ -175,15 +175,15 @@ alert( null == 0 ); // (2) false
 alert( null >= 0 ); // (3) *!*true*/!*
 ```
 
-З точки зору математики це дивно. Результат останнього порівняння показує, що "`null` більше або рівне нуля", в такому випадку, результат одного з порівнянь вище повинен бути `true`, але обидва вони `false`.
+З погляду математики це дивно. Результат останнього порівняння показує, що "`null` більше або дорівнює нулю", в такому випадку результат одного з порівнянь вище повинен бути `true`, але вони обидва `false`.
 
-Причина в тому що не строге порівняння `==` і порівняння `> < >= <=` працюють по-різному. Останні оператори конвертують `null` в число, розглядаючи його як `0`. Ось чому вираз (3) `null >= 0` дає `true`, а вираз (1) `null > 0` — `false`.
+Причина в тому що нестроге порівняння `==` і порівняння `> < >= <=` працюють по-різному. Останні оператори конвертують `null` в число, розглядаючи його як `0`. Ось чому вираз (3) `null >= 0` дає `true`, а вираз (1) `null > 0` — `false`.
 
-З іншого боку, для не строгого порівняння `==` значень `undefined` і `null` діє окреме правило: ці значення не перетворюються на інші типи, вони рівні один одному і не рівні будь-чому іншому. Ось чому вираз (2) `null == 0` повертає результат `false`.
+З іншого боку, для нестрогого порівняння `==` значень `undefined` і `null` діє окреме правило: ці значення не перетворюються на інші типи, вони рівні один одному і не рівні будь-чому іншому. Ось чому вираз (2) `null == 0` повертає результат `false`.
 
-### Непорівнюване значення undefined
+### Не порівнюйте значення undefined
 
-Значення `undefined` не рівне іншим значенням:
+Значення `undefined` не має порівнюватись з іншими значеннями:
 
 ```js run
 alert( undefined > 0 ); // false (1)
@@ -196,19 +196,19 @@ alert( undefined == 0 ); // false (3)
 Ми отримуємо такі результати, тому що:
 
 - Порівняння `(1)` і `(2)` повертає `false`, тому що `undefined` під час порівняння з "не null" значеннями завжди конвертується в `NaN`, а `NaN` — це спеціальне числове значення, яке завжди повертає `false` під час будь-яких порівнянь.
-- Не строге порівняння `(3)` повертає `false`, тому що `undefined` рівне тільки `null` і ніяким іншим значенням.
+- Нестроге порівняння `(3)` повертає `false`, тому що `undefined` рівне тільки `null`, `undefined` і жодним іншим значенням.
 
-### Уникайте проблем
+### Як уникати проблем
 
-Чому ми переглядали ці приклади? Чи повинні ми постійно пам'ятати про всі ці особливості? Не обов'язково. З часом, всі ці заплутані правила стануть для вас знайомими, але можна уникнути проблем, якщо дотримуватися простих правил:
+Чому ми переглядали ці приклади? Чи повинні ми постійно пам'ятати про всі ці особливості? Не обов'язково. З часом всі ці заплутані правила стануть для вас знайомими, але можна уникнути проблем, якщо дотримуватися надійних правил:
 
 - Будьте пильні під час порівняння будь-якого значення з `undefined/null`, за винятком строгого порівняння `===`.
-- Не використовуйте порівняння `>= > < <=` зі змінними, які можуть приймати значення `null/undefined`, якщо не впевнені в тому, що робите. Якщо змінна може приймати ці значення, то додайте для них окремі перевірки.
+- Не використовуйте порівняння `>= > < <=` зі змінними, які можуть приймати значення `null/undefined`, хіба що ви цілком впевнені в тому, що робите. Якщо змінна може приймати ці значення, то додайте для них окремі перевірки.
 
 ## Підсумки
 
 - Оператори порівняння повертають значення логічного типу.
 - Рядки порівнюються посимвольно в лексикографічному порядку.
 - Значення різних типів під час порівняння конвертуються в числа. Винятками є порівняння за допомогою операторів строгої рівності/нерівності.
 - Значення `null` і `undefined` рівні `==` один одному і не рівні будь-якому іншому значенню.
-- Будьте обережні під час використання операторів порівняння `>` чи `<` зі змінними, які можуть приймати значення `null/undefined`. Хорошою ідеєю буде зробити окрему перевірку на `null/undefined` для таких значень.
+- Будьте обережні, використовуючи оператори порівняння на зразок `>` чи `<` зі змінними, які можуть приймати значення `null/undefined`. Хорошою ідеєю буде зробити окрему перевірку на `null/undefined` для таких значень.