Update translation of 1.2.9

Author: vsemozhetbyt

1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md

@@ -13,9 +13,9 @@ null === +"\n0\n" → false
 Разъяснения:
 
 1. Очевидно, `true`.
-2. Используется посимвольное сравнение, поэтому `false`.
+2. Используется посимвольное сравнение, поэтому `false`. `"а"` меньше, чем `"я"`.
 3. Снова посимвольное сравнение. Первый символ первой строки `"2"` больше, чем первый символ второй `"1"`.
-4. Специальный случай. Значения `null` и `undefined` равны друг другу при нестрогом сравнении.
+4. Специальный случай. Значения `null` и `undefined` равны только друг другу при нестрогом сравнении.
 5. Строгое сравнение разных типов, поэтому `false`.
 6. Аналогично `(4)`, `null` равен только `undefined`.
 7. Строгое сравнение разных типов.

1-js/02-first-steps/09-comparison/article.md

@@ -1,15 +1,21 @@
 # Операторы сравнения
 
-Многие операторы сравнения известны нам из математики:
+Многие операторы сравнения известны нам из математики.
+
+В 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>.
+- Равно: `a == b`. Обратите внимание, для сравнения используется двойной знак равенства `==`. Один знак равенства `a = b` означал бы присваивание.
+- Не равно. В математике обозначается символом <code>&ne;</code>, но в JavaScript записывается как <code>a != b</code>.
+
+В этом разделе мы больше узнаем про то, какие бывают сравнения, как язык с ними работает и к каким неожиданностям мы должны быть готовы.
+
+В конце вы найдёте хороший рецепт того, как избегать "причуд" сравнения в JavaScript.
 
 ## Результат сравнения имеет логический тип
 
-Операторы сравнения, как и другие операторы, возвращают значение. Это значение имеет логический тип.
+Все операторы сравнения возвращают значение логического типа:
 
 - `true` -- означает "да", "верно", "истина".
 - `false` -- означает "нет", "неверно", "ложь".
@@ -39,23 +45,23 @@ alert( result ); // true
 
 ```js run
 alert( 'Я' > 'А' ); // true
-alert( 'Кот' > 'Код' ); // true
+alert( 'Коты' > 'Кода' ); // true
 alert( 'Сонный' > 'Сон' ); // true
 ```
 
 Алгоритм сравнения двух строк довольно прост:
 
 1. Сначала сравниваются первые символы строк.
-2. Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй.
+2. Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй. Сравнение завершено.
 3. Если первые символы равны, то таким же образом сравниваются уже вторые символы строк.
 4. Сравнение продолжается, пока не закончится одна из строк.
 5. Если обе строки заканчиваются одновременно, то они равны. Иначе, большей считается более длинная строка.
 
-В примерах выше сравнение `'Я' > 'А'` завершится на первом шаге, тогда как строки `"Кот"` и `"Код"` будут сравниваться посимвольно:
+В примерах выше сравнение `'Я' > 'А'` завершится на первом шаге, тогда как строки `'Коты'` и `'Кода'` будут сравниваться посимвольно:
 
 1. `К` равна `К`.
 2. `о` равна `о`.
-3. `т` больше чем `д`. На этом сравнение заканчивается. Первая строка больше.
+3. `т` больше, чем `д`. На этом сравнение заканчивается. Первая строка больше.
 
 ```smart header="Используется кодировка Unicode, а не настоящий алфавит"
 Приведённый выше алгоритм сравнения похож на алгоритм, используемый в словарях и телефонных книгах, но между ними есть и различия.
@@ -134,11 +140,11 @@ alert( 0 === false ); // false, так как сравниваются разн
 
 Ещё есть оператор строгого неравенства `!==`, аналогичный `!=`.
 
-Оператор строгого равенства дольше писать, но он делает код более очевидным и оставляет меньше мест для ошибок.
+Оператор строгого равенства дольше писать, но он делает код более очевидным и оставляет меньше места для ошибок.
 
 ## Сравнение с null и undefined
 
-Поведение `null` и `undefined` при сравнении с другими значениями - особое:
+Поведение `null` и `undefined` при сравнении с другими значениями — особое:
 
 При строгом равенстве `===`
 : Эти значения различны, так как различны их типы.
@@ -175,7 +181,7 @@ alert( null >= 0 ); // (3) *!*true*/!*
 
 С другой стороны, для нестрогого равенства `==` значений `undefined` и `null` действует особое правило: эти значения ни к чему не приводятся, они равны друг другу и не равны ничему другому. Поэтому (2) `null == 0` ложно.
 
-### Несравнимое значение undefined
+### Несравненное значение undefined
 
 Значение `undefined` несравнимо с другими значениями:
 
@@ -190,20 +196,19 @@ alert( undefined == 0 ); // false (3)
 На это есть следующие причины:
 
 - Сравнения `(1)` и `(2)` возвращают `false`, потому что `undefined` преобразуется в `NaN`, а `NaN` – это специальное числовое значение, которое возвращает `false` при любых сравнениях.
-- Нестрогое равенство `(3)` возвращает `false`, потому что `undefined` равно только `null` и ничему больше.
+- Нестрогое равенство `(3)` возвращает `false`, потому что `undefined` равно только `null`, `undefined` и ничему больше.
 
 ### Как избежать проблем
 
-Зачем мы рассмотрели все эти примеры? Должны ли мы постоянно помнить обо всех этих особенностях? Не обязательно. Со временем все они станут вам знакомы, но можно избежать проблем, если следовать простому правилу.
-
-Просто относитесь к любому сравнению с `undefined/null`, кроме строгого равенства `===`, с осторожностью.
+Зачем мы рассмотрели все эти примеры? Должны ли мы постоянно помнить обо всех этих особенностях? Не обязательно. Со временем все они станут вам знакомы, но можно избежать проблем, если следовать надёжным правилам:
 
-Не используйте сравнения `>= > < <=` с переменными, которые могут принимать значения `null/undefined`, если вы не уверены в том, что делаете. Если переменная может принимать эти значения, то добавьте для них отдельные проверки.
+- Относитесь очень осторожно к любому сравнению с `undefined/null`, кроме случаев строгого равенства `===`.
+- Не используйте сравнения `>= > < <=` с переменными, которые могут принимать значения `null/undefined`, разве что вы полностью уверены в том, что делаете. Если переменная может принимать эти значения, то добавьте для них отдельные проверки.
 
 ## Итого
 
 - Операторы сравнения возвращают значения логического типа.
 - Строки сравниваются посимвольно в лексикографическом порядке.
 - Значения разных типов при сравнении приводятся к числу. Исключением является сравнение с помощью операторов строгого равенства/неравенства.
 - Значения `null` и `undefined` равны `==` друг другу и не равны любому другому значению.
-- Будьте осторожны при использовании операторов сравнений `>` и `<` с переменными, которые могут принимать значения `null/undefined`. Хорошей идеей будет сделать отдельную проверку на `null/undefined`.
+- Будьте осторожны при использовании операторов сравнений вроде `>` и `<` с переменными, которые могут принимать значения `null/undefined`. Хорошей идеей будет сделать отдельную проверку на `null/undefined`.