Update article.md

Author: Kichikahunov

1-js/02-first-steps/07-operators/article.md

@@ -85,7 +85,7 @@ let y = -2;
 alert( +y ); // -2
 
 *!*
-// Преобразует в числа
+// Преобразует не-числа в число
 alert( +true ); // 1
 alert( +"" );   // 0
 */!*
@@ -127,15 +127,15 @@ alert( +apples + +oranges ); // 5
 
 ## Приоритет операторов
 
-В том случае, если в выражении есть несколько операторов – порядок их выполнения определяется *приоритетом*, или, другими словами, существует неявный порядок приоритетов операторов.
+В том случае, если в выражении есть несколько операторов – порядок их выполнения определяется *приоритетом*, или, другими словами, существует определённый порядок выполнения операторов.
 
-Из школы мы знаем, что умножение в выражении `2 * 2 + 1` выполнится раньше сложения, т.к. его *приоритет* выше. Говорят, что умножение имеет более высокий *приоритет*, чем сложение.
+Из школы мы знаем, что умножение в выражении `2 * 2 + 1` выполнится раньше сложения. Это как раз и есть "приоритет". Говорят, что умножение имеет более высокий приоритет, чем сложение.
 
-Скобки переопределяют любой приоритет, так что если мы не удовлетворены неявным порядком, мы можем использовать их, чтобы изменить приоритет. Например: `(1 + 2) * 2`.
+Скобки важнее, чем приоритет, так что если мы не удовлетворены порядком по умолчанию, мы можем использовать их, чтобы изменить приоритет. Например, написать `(1 + 2) * 2`.
 
 В JavaScript много операторов. Каждый оператор имеет соответствующий номер приоритета. Тот, у кого это число больше – выполнится раньше. Если приоритет одинаковый, то порядок выполнения – слева направо.
 
-Отрывок из [таблицы приоритетов](https://developer.mozilla.org/ru/JavaScript/Reference/operators/operator_precedence) (нет необходимости всё запоминать, но помните, что у унарных операторов приоритет выше, чем у бинарных):
+Отрывок из [таблицы приоритетов](https://developer.mozilla.org/ru/JavaScript/Reference/operators/operator_precedence) (нет необходимости всё запоминать, обратите внимание, что у унарных операторов приоритет выше, чем у соответствующих бинарных):
 
 | Приоритет | Название | Обозначение |
 |------------|------|------|
@@ -181,7 +181,7 @@ alert( c ); // 4
 Такое присваивание работает справа-налево. Сначала вычисляется самое правое выражение `2 + 2`, и затем оно присвоится переменным слева: `c`, `b` и `a`. В конце у всех переменных будет одно значение.
 
 ````smart header="Оператор `\"=\"` возвращает значение"
-Все операторы возвращают значение. Для некоторых это более очевидно, например сложение `+` или умножение `*`. Оператор присваивания не является исключением.
+Все операторы возвращают значение. Для некоторых это очевидно, например сложение `+` или умножение `*`. Но и оператор присваивания не является исключением.
 
 Вызов `x = value` записывает `value` в `x` *и возвращает его*.
 
@@ -199,14 +199,14 @@ alert( a ); // 3
 alert( c ); // 0
 ```
 
-В примере выше результатом `(a = b + 1)` будет значение, которое присваивается в `a` (то есть `3`). Потом оно вычитается от `3`.
+В примере выше результатом `(a = b + 1)` будет значение, которое присваивается в `a` (то есть `3`). Потом оно используется для дальнейших вычислений.
 
-Забавное применение присваивания, не так ли? Нам нужно понимать, как это работает, потому что иногда это можно увидеть в сторонних библиотеках, но писать самим в таком стиле не рекомендуется. Такие трюки не сделают ваш код более понятным или читабельным.
+Забавное применение присваивания, не так ли? Нам нужно понимать, как это работает, потому что иногда это можно увидеть в JavaScript-библиотеках, но писать самим в таком стиле не рекомендуется. Такие трюки не сделают ваш код более понятным или читабельным.
 ````
 
 ## Остаток от деления %
 
-Оператор взятия остатка `%` интересен тем, что, несмотря на обозначение, никакого отношения к процентам не имеет.
+Оператор взятия остатка `%`, несмотря на обозначение, никакого отношения к процентам не имеет..
 
 Его результат `a % b` – это остаток от деления `a` на `b`.
 
@@ -237,11 +237,11 @@ alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)
 Например:
 
 ```js run
-alert( 4 ** (1/2) ); // 2 (степень 1/2 равна квадратному корню)
-alert( 8 ** (1/3) ); // 2 (степень 1/3 равна кубическому корю)
+alert( 4 ** (1/2) ); // 2 (степень 1/2 эквивалентна взятию квадратного корня)
+alert( 8 ** (1/3) ); // 2 (степень 1/3 равна взятию кубического корня)
 ```
 
-## Инкремент/декремент: ++, --
+## Инкремент/декремент
 
 <!-- Can't use -- in title, because built-in parse turns it into – -->
 
@@ -265,7 +265,7 @@ alert( 8 ** (1/3) ); // 2 (степень 1/3 равна кубическому
     ```
 
 ```warn
-Инкремент/декремент можно применить только к переменной. Код 5++ вернёт ошибку.
+Инкремент/декремент можно применить только к переменной. Попытка использовать его на значении, типа 5++, вернёт ошибку.
 ```
 
 Операторы `++` и `--` могут быть расположены не только после, но и до переменной.
@@ -275,11 +275,11 @@ alert( 8 ** (1/3) ); // 2 (степень 1/3 равна кубическому
 
 Обе эти формы записи делают одно и то же: увеличивают `counter` на `1`.
 
-Есть ли разница между ними? Да, но увидеть её мы сможем, если будем использовать возвращаемое значение `++/--`.
+Есть ли разница между ними? Да, но увидеть её мы сможем, только если будем значение, которое возвращают `++/--`.
 
-Давайте уточним. Как мы знаем, все операторы возвращают значение. Операторы инкремент/декремент не исключение. Префиксная форма возвращает новое значение, в то время как постфиксная форма возвращает старое (до увеличения/уменьшения числа).
+Давайте проясним этот момент. Как мы знаем, все операторы возвращают значение. Операторы инкремент/декремент не исключение. Префиксная форма возвращает новое значение, в то время как постфиксная форма возвращает старое (до увеличения/уменьшения числа).
 
-Пример:
+Чтобы увидеть разницу, вот небольшой пример:
 
 ```js run
 let counter = 1;
@@ -309,15 +309,15 @@ alert(a); // *!*1*/!*
     let counter = 0;
     counter++;
     ++counter;
-    alert( counter ); // 2, `++counter` и `counter++` просто увеличивают число
+    alert( counter ); // 2, обе строки сделали одно и то же
     ```
 - Если хочется тут же использовать результат, то нужна префиксная форма:
 
     ```js run
     let counter = 0;
     alert( ++counter ); // 1
     ```
-- Если нужно увеличить, но нужно значение переменной *до увеличения* – постфиксная форма:
+- Если нужно увеличить, и при этом получить значение переменной *до увеличения* – постфиксная форма:
 
     ```js run
     let counter = 0;
@@ -394,7 +394,7 @@ n *= 2; // теперь n=14 (работает как n = n * 2)
 alert( n ); // 14
 ```
 
-Так можно сделать для операторов `+,-,*,/,%` и бинарных `<<,>>,>>>,&,|,^`.
+Подобные краткие формы записи существуют для всех арифметических и побитовых операторов: `/=`, `-=` и так далее.
 
 Вызов с присваиванием имеет в точности такой же приоритет, как обычное присваивание, то есть выполнится после большинства других операций:
 
@@ -408,7 +408,7 @@ alert( n ); // 16  (сначала выполнится правая часть,
 
 ## Оператор запятая
 
-Оператор `,` редко используется и является одним из самых необычных. Иногда он используется для написания более короткого кода, поэтому нам нужно знать его, чтобы понимать, что происходит.
+Оператор "запятая" `,` редко используется и является одним из самых необычных. Иногда он используется для написания более короткого кода, поэтому нам нужно знать его, чтобы понимать, что при этом происходит.
 
 Оператор запятая предоставляет нам возможность вычислять несколько выражений, разделяя их запятой `,`. Каждое выражение выполняется, но возвращается результат только последнего.
 
@@ -427,12 +427,12 @@ alert( a ); // 7 (результат 3 + 4)
 ```smart header="Запятая имеет очень низкий приоритет"
 Пожалуйста, обратите внимание, что оператор запятая имеет очень низкий приоритет, приоритет которого ниже `=`, поэтому скобки важны в приведённом примере выше.
 
-Без них: `a = 1 + 2, 3 + 4` сначала выполнится `+`, суммируя числа в `a = 3, 7`, затем оператор присваивания `=` присвоит `a = 3`, и в конце число не будет обработано, поэтому игнорируется.
+Без них в `a = 1 + 2, 3 + 4` сначала выполнится `+`, суммируя числа в `a = 3, 7`, затем оператор присваивания `=` присвоит `a = 3`, а то что идёт дальше, будет игнорировано. Всё так же, как в `(a = 1 + 2), 3+4`.
 ```
 
-Зачем нам оператор, который отбрасывает всё, кроме последней части?
+Зачем нам оператор, который отбрасывает всё, кроме последнего выражения?
 
-Обычно он используется в составе более сложных конструкций, чтобы сделать несколько действий в одной строке.
+Иногда его используют в составе более сложных конструкций, чтобы сделать несколько действий в одной строке.
 
 Например:
 
@@ -443,4 +443,4 @@ for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
 }
 ```
 
-Такие трюки используются во многих JavaScript-фреймворках. Вот почему мы упоминаем их. Но, обычно, они не улучшают читабельность кода, поэтому нам нужно сначала подумать, прежде чем их использовать. 
+Такие трюки используются во многих JavaScript-фреймворках. Вот почему мы упоминаем их. Но обычно они не улучшают читабельность кода, поэтому стоит хорошо подумать, прежде чем их использовать.