minor fixes

Author: iliakan

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -4,47 +4,47 @@
 
 Оператор нулевого слияния представляет собой два вопросительных знака `??`.
 
-Так как он рассматривает `null` и `undefined` аналогично, мы введём специальный термин. Мы будем говорить, что выражение "определено", только если оно не равняется ни `null`, ни `undefined`.
+Так как он обрабатывает `null` и `undefined` одинаковым образом, то для этой статьи мы введём специальный термин. Для краткости будем говорить, что значение "определено",  если оно не равняется ни `null`, ни `undefined`.
 
 Результат выражения `a ?? b` будет следующим:
-- `a`, если значение `a` определено,
-- `b`, если значение `a` не определено.
+- если `a` определено, то `a`,
+- если `a` не определено, то `b`.
 
-То есть оператор `??` возвращает первый аргумент, если он не `null/undefined`, иначе второй.
+Иначе говоря, оператор `??` возвращает первый аргумент, если он не `null/undefined`, иначе второй.
 
-Оператор нулевого слияния не является чем-то принципиально новым. Это всего лишь удобный синтаксис, как из двух значений получить одно "определённое".
+Оператор нулевого слияния не является чем-то принципиально новым. Это всего лишь удобный синтаксис, как из двух значений получить одно, которое "определено".
 
 Вот как можно переписать выражение `result = a ?? b`, используя уже знакомые нам операторы:
 
 ```js
 result = (a !== null && a !== undefined) ? a : b;
 ```
 
-Теперь должно быть абсолютно ясно, что `??` делает. Давайте посмотрим, где это может быть полезно.
+Теперь должно быть абсолютно ясно, что делает `??`. Давайте посмотрим, где это может быть полезно.
 
-Как правило, оператор `??` нужен для того, чтобы задать значение по умолчанию для потенциально неопределённой переменной.
+Как правило, оператор `??` нужен для того, чтобы задать значение по умолчанию для потенциально не с переменной.
 
-Например, здесь мы отобразим `user`, если он определен, в противном случае `Аноним`:
+Например, здесь мы отобразим `user`, если её значение не `null/undefined`, в противном случае `Аноним`:
 
 ```js run
 let user;
 
-alert(user ?? "Аноним"); // Аноним (user не определен)
+alert(user ?? "Аноним"); // Аноним (user не существует)
 ```
 
-Вот пример `user`, с присвоенным именем:
+А вот пример, когда `user` присвоено значение:
 
 ```js run
 let user = "Иван";
 
-alert(user ?? "Аноним"); // Иван (user определен)
+alert(user ?? "Аноним"); // Иван (user существует)
 ```
 
 Кроме этого, можно записать последовательность из операторов `??`, чтобы получить первое значение из списка, которое не является `null/undefined`.
 
-Допустим, у нас есть данные пользователя в переменных `firstName`, `lastName` или `nickName`. Все они могут быть не определены, если пользователь решил не вводить значение.
+Допустим, у нас есть данные пользователя в переменных `firstName`, `lastName` или `nickName`. Все они могут не существовать, если пользователь решил не вводить соответствующие значение.
 
-Мы хотели бы отобразить имя пользователя, используя одну из этих переменных, или показать "Анонимный", если все они не определены.
+Мы хотели бы отобразить имя пользователя, используя одну из этих переменных, или показать "Аноним", если все они `null/undefined`.
 
 Для этого воспользуемся оператором `??`:
 
@@ -53,7 +53,7 @@ let firstName = null;
 let lastName = null;
 let nickName = "Суперкодер";
 
-// показывает первое определённое значение:
+// показывает первое значение, которое определено:
 *!*
 alert(firstName ?? lastName ?? nickName ?? "Аноним"); // Суперкодер
 */!*
@@ -76,19 +76,19 @@ alert(firstName || lastName || nickName || "Аноним"); // Суперкод
 */!*
 ```
 
-Исторически сложилось так, что оператор ИЛИ `||` появился первым. Он существует с самого начала существования JavaScript, поэтому разработчики долгое время использовали его для таких целей.
+Исторически сложилось так, что оператор ИЛИ `||` появился первым. Он существует с самого начала в JavaScript, поэтому разработчики долгое время использовали его для таких целей.
 
-С другой стороны, сравнительно недавно в язык был добавлен оператор нулевого слияния `??` как раз потому, что многие были недовольны оператором `||`.
+С другой стороны, сравнительно недавно в язык был добавлен оператор нулевого слияния `??` - как раз потому, что многие были недовольны оператором `||`.
 
 Важное различие между ними заключается в том, что:
 - `||` возвращает первое *истинное* значение.
 - `??` возвращает первое *определённое* значение.
 
-Проще говоря, оператор `||` не различает `false`, `0`, пустую строку `""` и `null/undefined`. Для него они все одинаковые, т.е. являются ложными значениями. Если первым аргументом для оператора `||` будет любое из перечисленных значений, то в качестве результата мы получим второй аргумент.
+Проще говоря, оператор `||` не различает `false`, `0`, пустую строку `""` и `null/undefined`. Для него они все одинаковы, т.е. являются ложными значениями. Если первым аргументом для оператора `||` будет любое из перечисленных значений, то в качестве результата мы получим второй аргумент.
 
 Однако на практике часто требуется использовать значение по умолчанию только тогда, когда переменная является `null/undefined`. Ведь именно тогда значение действительно неизвестно/не определено.
 
-Например, рассмотрим следующий пример:
+Рассмотрим следующий пример:
 
 ```js run
 let height = 0;
@@ -97,20 +97,20 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-- `height || 100` проверяет `height` на наличие ложного значения, оно равно `0`, так что это действительно false.
+- `height || 100` проверяет `height` на ложное значение, оно равно `0`, да, ложное.
     - поэтому результатом `||` является второй аргумент, т.е. `100`.
 - `height ?? 100` проверяет, что переменная `height` содержит `null/undefined`, а поскольку это не так,
     - то результатом является сама переменная `height`, т.е. `0`.
 
-На практике нулевая высота часто является вполне возможным значением, которое не следует заменять значением по умолчанию. Таким образом, `??` делает все правильно.
+На практике нулевая высота часто является вполне нормальным значением, которое не следует заменять значением по умолчанию. Таким образом, `??` здесь как раз работает так, как нужно.
 
 ## Приоритет
 
 Приоритет оператора `??` такой же, как и у `||`. Они оба равны `4` в [таблице на MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
 
 Это означает, что, как и `||`, оператор нулевого слияния `??` вычисляется до `=` и `?`, но после большинства других операций, таких как `+`, `*`.
 
-Из этого следует, что если нужно выбрать значение при помощи оператора `??` вместе с другими операторами в выражении, следует добавить круглые скобки:
+Так что, в выражениях такого вида понадобятся скобки:
 
 ```js run
 let height = null;
@@ -122,29 +122,29 @@ let area = (height ?? 100) * (width ?? 50);
 alert(area); // 5000
 ```
 
-Иначе, если опустить скобки, то оператор `*` выполнится первым, так как у него приоритет выше, чем у `??`, а это приведёт к неправильным результатам.
+Иначе, если опустить скобки, оператор `*` выполнится первым, так как у него приоритет выше, чем у `??`, и это приведёт к неправильным результатам.
 
 ```js
-// без круглых скобок
+// без скобок
 let area = height ?? 100 * width ?? 50;
 
-// ...то же самое, что предыдущее выражение (вероятно, это не то, что нам нужно):
+// ...сработает вот так (совсем не как нам нужно):
 let area = height ?? (100 * width) ?? 50;
 ```
 
 ### Использование ?? вместе с && или ||
 
-По соображениям безопасности JavaScript запрещает использование оператора `??` вместе с `&&` и `||`, если только приоритет явно не указан в круглых скобках.
+По соображениям безопасности JavaScript запрещает использование оператора `??` вместе с `&&` и `||`, если приоритет явно не указан при помощи круглых скобок.
 
 Выполнение следующего кода приведёт к синтаксической ошибке:
 
 ```js run
 let x = 1 && 2 ?? 3; // Синтаксическая ошибка
 ```
 
-Ограничение безусловно спорное, оно было добавлено в спецификацию языка с целью избежать программные ошибки, когда люди начнут переключаться с `||` на `??`.
+Это, безусловно спорное, ограничение было добавлено в спецификацию языка с целью избежать программные ошибки, когда люди начнут переходить с `||` на `??`.
 
-Используйте круглые скобки, чтобы обойти это ограничение: 
+Используйте скобки, чтобы обойти это ограничение:
 
 ```js run
 *!*
@@ -166,4 +166,4 @@ alert(x); // 2
     ```
 
 - Оператор `??` имеет очень низкий приоритет, лишь немного выше, чем у `?` и `=`, поэтому при использовании его в выражении, скорее всего, потребуются скобки.
-- Запрещено использовать вместе с `||` или `&&` без явно указанных круглых скобок.
+- Запрещено использовать вместе с `||` или `&&` без явно указанного приоритета, то есть без скобок.