Перевод Logical_Operators (#4073)

* Перевод Logical_Operators

3 files changed, 409 insertions, 0 deletions

diff --git a/files/ru/web/javascript/reference/operators/logical_and/index.md b/files/ru/web/javascript/reference/operators/logical_and/index.md
new file mode 100644
index 0000000000..960d6ef3d1
--- /dev/null
+++ b/files/ru/web/javascript/reference/operators/logical_and/index.md
@@ -0,0 +1,163 @@
+---
+title: Логическое И (&&)
+slug: Web/JavaScript/Reference/Operators/Logical_AND
+tags:
+  - JavaScript
+  - Language feature
+  - Logical Operator
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_and
+---
+{{jsSidebar("Operators")}}
+
+Логический оператор И (`&&`) (конъюнкция) для набора операндов со значением типа {{jsxref("Boolean")}} будет `true` только в случае, если все операнды содержат значение `true`. В противном случае это будет `false`.
+
+В целом, оператор вернёт значение первого {{Glossary("falsy", "ложноподобного")}} операнда при вычислении, либо значение последнего операнда, если все операнды оказались {{Glossary("truthy", "истиноподобными")}}.
+
+{{EmbedInteractiveExample("pages/js/expressions-logical-and.html", "shorter")}}
+
+## Синтаксис
+
+```js
+expr1 && expr2
+```
+
+## Описание
+
+Логическое И (`&&`) вычисляет операнды слева направо, возвращая сразу значение первого попавшего {{Glossary("falsy", "ложноподобного")}} операнда; если все значения {{Glossary("truthy", "истиноподобны")}}, возвращается значение последнего операнда.
+
+Если значение может быть преобразовано в `true`, то оно рассматривается как {{Glossary("truthy", "истиноподобное (truthy)")}}. Если же значение может быть преобразовано в `false`, то оно называется {{Glossary("falsy", "ложноподобным (falsy)")}}.
+
+Примеры выражений, которые могут быть преобразованы в `false`:
+
+- `false`;
+- `null`;
+- `NaN`;
+- `0`;
+- пустая строка (`""`, `''`, ` `` `);
+- `undefined`.
+
+Оператор И возвращает небулевы значения как есть:
+
+```js
+result = '' && 'foo';  // result is assigned "" (empty string)
+result = 2 && 0;       // result is assigned 0
+result = 'foo' && 4;   // result is assigned 4
+```
+
+Несмотря на то, что оператор `&&` может использоваться с операндами, не содержащие логических значений, он всё равно останется булевым оператором, поскольку его возвращаемое значение всегда можно преобразовать в [булевый примитив](/ru/docs/Web/JavaScript/Data_structures#Boolean_type).
+Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной [`оператор НЕ`](/en-US/docs/Web/JavaScript/Reference/Operators/Logical_NOT) или конструктор {{jsxref("Global_Objects/Boolean/Boolean", "Boolean")}}.
+
+### Сокращённое вычисление
+
+Оператор логического И вычисляет выражение по сокращённой схеме.
+Каждый операнд приводится к булевому значению, если результат одного преобразования оказывается `false`, тогда оператор И останавливает дальнейшее вычисление выражения и возвращает исходное значение этого ложноподобного операнда. Поэтому оставшиеся операнды **не** будут вычислены.
+
+В качестве примера рассмотрим следующий псевдокод.
+
+```
+(ложноподобное выражение) && следующее выражение
+```
+
+Поскольку первый операнд `(ложноподобное выражение)` имеет ложное значение, то `следующее выражение` **никогда не будет вычислено**.
+Если `следующее выражение` содержало функцию, то она бы никогда не была вызвана.
+Посмотрите пример ниже:
+
+```js
+function A() { console.log('вызвана функция A'); return false; }
+function B() { console.log('вызвана функция B'); return true; }
+
+console.log( A() && B() );
+// В результате вызова функции A, в консоли будет выведено "вызвана функция A",
+// а оператор && вычислится как false (функция A возвращает false), поэтому далее в консоли появится false;
+// вследствие этого оператор И прекратит вычисление и проигнорирует функцию B
+```
+
+### Приоритет операторов
+
+Оператор И имеет более высокий приоритет, чем оператор ИЛИ, поэтому оператор `&&` выполнится раньше оператора `||` (см. [приоритет операторов](/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)).
+
+```js
+false || true && true            // вернёт true
+true && (false || false)         // вернёт false
+(2 == 3) || (4 < 0) && (1 == 1)  // вернёт false
+```
+
+## Примеры
+
+### Использование оператора И
+
+В следующем коде показаны примеры использования оператора `&&` (логическое И).
+
+```js
+a1 = true  && true       // t && t вернёт true
+a2 = true  && false      // t && f вернёт false
+a3 = false && true       // f && t вернёт false
+a4 = false && (3 == 4)   // f && f вернёт false
+a5 = 'Cat' && 'Dog'      // t && t вернёт "Dog"
+a6 = false && 'Cat'      // f && t вернёт false
+a7 = 'Cat' && false      // t && f вернёт false
+a8 = ''    && false      // f && f вернёт ""
+a9 = false && ''         // f && f вернёт false
+```
+
+### Правила преобразования булевых значений
+
+#### Конвертация И к ИЛИ
+
+Следующая операция с **булевыми значениями**:
+
+```js
+bCondition1 && bCondition2
+```
+
+всегда эквивалентна:
+
+```js
+!(!bCondition1 || !bCondition2)
+```
+
+#### Конвертация ИЛИ к И
+
+Следующая операция с **булевыми значениями**:
+
+```js
+bCondition1 || bCondition2
+```
+
+всегда эквивалентна:
+
+```js
+!(!bCondition1 && !bCondition2)
+```
+
+### Удаление вложенных круглых скобок
+
+Поскольку логические выражения вычисляются слева направо, всегда можно удалить круглые скобки из сложного выражения при условии соблюдения определенных правил.
+
+Следующая составная операция с **булевыми значениями**:
+
+```js
+bCondition1 || (bCondition2 && bCondition3)
+```
+
+это то же самое, что и:
+
+```js
+bCondition1 || bCondition2 && bCondition3
+```
+
+## Спецификации
+
+{{Specifications}}
+
+## Поддержка браузерами
+
+{{Compat}}
+
+## Смотрите также
+
+- {{jsxref("Boolean")}}
+- {{Glossary("Truthy")}}
+- {{Glossary("Falsy")}}
diff --git a/files/ru/web/javascript/reference/operators/logical_not/index.md b/files/ru/web/javascript/reference/operators/logical_not/index.md
new file mode 100644
index 0000000000..ea5ead94b6
--- /dev/null
+++ b/files/ru/web/javascript/reference/operators/logical_not/index.md
@@ -0,0 +1,96 @@
+---
+title: Логическое НЕ (!)
+slug: Web/JavaScript/Reference/Operators/Logical_NOT
+tags:
+  - JavaScript
+  - Language feature
+  - Logical Operator
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_not
+---
+{{jsSidebar("Operators")}}
+
+Логический оператор НЕ (`!`) (логическое отрицание) меняет логическое значение операнда с истины в ложь и наоборот. Обычно он используется с {{jsxref("Boolean", "булевыми")}} (логическими) значениями. При использовании с любыми другими значениями, если операнд может быть преобразован в `true`, то вернёт `false`; в противном случае он возвращается `true`.
+
+{{EmbedInteractiveExample("pages/js/expressions-logical-not.html", "shorter")}}
+
+## Синтаксис
+
+```js
+!expr
+```
+
+## Описание
+
+Возвращает `false`, если операнд может быть преобразован в `true`; в противном случае возвращается `true`.
+
+Если значение может быть преобразовано в `true`, то оно рассматривается как {{Glossary("truthy", "истинноподобное (truthy)")}}. Если же значение может быть преобразовано в `false`, то оно называется {{Glossary("falsy", "ложноподобным (falsy)")}}.
+
+Примеры выражений, которые могут быть преобразованы в `false`:
+
+- `null`;
+- `NaN`;
+- `0`;
+- пустая строка (`""`, `''`, ` `` `);
+- `undefined`.
+
+Несмотря на то, что оператор `!` может использоваться с операндами, значения которых не относится к типу Boolean, это всё равно булевый оператор, поскольку его возвращаемое значение всегда можно преобразовать в [булевый примитив](/ru/docs/Web/JavaScript/Data_structures#Boolean_type). Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной [оператор НЕ](/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT) или конструктор {{jsxref("Global_Objects/Boolean/Boolean", "Boolean")}}.
+
+## Примеры
+
+### Использование логического НЕ
+
+В следующем коде показаны примеры использования оператора `!` (логическое НЕ).
+
+```js
+n1 = !true               // !t вернёт false
+n2 = !false              // !f вернёт true
+n3 = !''                 // !f вернёт true
+n4 = !'Cat'              // !t вернёт false
+```
+
+### Двойное НЕ (`!!`)
+
+Можно один за другим использовать пару операторов НЕ, чтобы явным образом принудительно преобразовать любое значение в соответствующий [булевый примитив](/en-US/docs/Web/JavaScript/Data_structures#Boolean_type).
+Преобразование основано на "истинноподобности" или "ложноподобности" значения (см. {{Glossary("truthy")}} и {{Glossary("falsy")}})).
+
+Точно такое же преобразование может быть выполнено с помощью функции {{jsxref("Global_Objects/Boolean/Boolean",
+  "Boolean")}}.
+
+```js
+n1 = !!true                   // !!truthy вернёт true
+n2 = !!{}                     // !!truthy вернёт true: любой объект - истинноподобный...
+n3 = !!(new Boolean(false))   // ...даже Boolean-объект со значением false из вызова .valueOf()!
+n4 = !!false                  // !!falsy вернёт false
+n5 = !!""                     // !!falsy вернёт false
+n6 = !!Boolean(false)         // !!falsy вернёт false
+```
+
+### Конвертация операторов НЕ
+
+Следующая операция с **булевыми значениями**:
+
+```js
+!!bCondition
+```
+
+всегда эквивалентна:
+
+```js
+bCondition
+```
+
+## Спецификации
+
+{{Specifications}}
+
+## Поддержка браузерами
+
+{{Compat}}
+
+## Смотрите также
+
+- {{jsxref("Boolean")}}
+- {{Glossary("Truthy")}}
+- {{Glossary("Falsy")}}
diff --git a/files/ru/web/javascript/reference/operators/logical_or/index.md b/files/ru/web/javascript/reference/operators/logical_or/index.md
new file mode 100644
index 0000000000..d5a66f8ea3
--- /dev/null
+++ b/files/ru/web/javascript/reference/operators/logical_or/index.md
@@ -0,0 +1,150 @@
+---
+title: Логическое ИЛИ (||)
+slug: Web/JavaScript/Reference/Operators/Logical_OR
+tags:
+  - JavaScript
+  - Language feature
+  - Logical Operator
+  - Operator
+  - Reference
+browser-compat: javascript.operators.logical_or
+---
+{{jsSidebar("Operators")}}
+
+Логический оператор ИЛИ (`||`) (дизъюнкция) для набора операндов истинен будет `true` только в случае, если один или несколько его операндов имеют значение `true`.
+
+Обычно используется с {{jsxref("Boolean", "булевыми")}} (логическими) значениями. Тогда возвращается булевое значение. Однако фактически оператор `||` возвращает значение одного из операндов, поэтому если этот оператор используется с небулевыми значениями, он вернет небулевое значение.
+
+{{EmbedInteractiveExample("pages/js/expressions-logical-or.html", "shorter")}}
+
+## Синтаксис
+
+```js
+expr1 || expr2
+```
+
+## Описание
+
+Если `expr1` может быть преобразовано в `true`, то вернётся `expr1`; в противном случае возвращается `expr2`.
+
+Если значение может быть преобразовано в `true`, то оно рассматривается как {{Glossary("truthy", "истиноподобное (truthy)")}}. Если же значение может быть преобразовано в `false`, то оно называется {{Glossary("falsy", "ложноподобным (falsy)")}}.
+
+Примеры выражений, которые могут быть преобразованы в `false`:
+
+- `null`;
+- `NaN`;
+- `0`;
+- пустая строка (`""`, `''`, ` `` `);
+- `undefined`.
+
+Несмотря на то, что оператор `||` может использоваться с операндами без логических значений, это всё равно булевый оператор, поскольку его возвращаемое значение всегда можно преобразовать в [булевый примитив](/ru/docs/Web/JavaScript/Data_structures#Boolean_type).
+Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной {{JSxRef("Operators/Logical_NOT", "оператор НЕ")}} или конструктор {{jsxref("Global_Objects/Boolean/Boolean", "Boolean")}}.
+
+### Сокращённое вычисление
+
+Оператор логического ИЛИ вычисляется слева направо, делая возможным сокращённое вычисление выражения, согласно следующему правилу:
+
+`(истинноподобное выражение) || следующее выражение` — вычисление останавливается на истинноподобном выражении;
+
+Сокращенное вычисление хорошо тем, что `следующее выражение` не будет **вычислено**, т.е. всё, связанное с ним, будет проигнорировано (например, если
+`следующее выражение` представляет собой вызов функции, то он никогда не произойдёт). Всё потому, что значение оператора известно уже после вычисления первого операнда. Посмотрите на пример:
+
+```js
+function A(){ console.log('вызвана функция A'); return false; }
+function B(){ console.log('вызвана функция B'); return true; }
+
+console.log( B() || A() );
+// В результате вызова функции B, в консоли будет выведено "вызвана функция B",
+// а далее в консоли появится false (это результат оператора)
+```
+
+### Приоритет операторов
+
+Следующие выражения могут показаться эквивалентными, но это не так, потому что оператор `&&` выполняется до оператора `||` (см. [приоритет операторов](/ru/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)).
+
+```js
+true || false && false      // вернёт true, поскольку сначала вычисляется && 
+(true || false) && false    // вернёт false, поскольку у группировки выше приоритет
+```
+
+## Примеры
+
+### Использование оператора ИЛИ
+
+В следующем коде показаны примеры использования оператора `||` (логическое ИЛИ).
+
+```js
+o1 = true  || true       // t || t вернёт true
+o2 = false || true       // f || t вернёт true
+o3 = true  || false      // t || f вернёт true
+o4 = false || (3 == 4)   // f || f вернёт false
+o5 = 'Cat' || 'Dog'      // t || t вернёт "Cat"
+o6 = false || 'Cat'      // f || t вернёт "Cat"
+o7 = 'Cat' || false      // t || f вернёт "Cat"
+o8 = ''    || false      // f || f вернёт false
+o9 = false || ''         // f || f вернёт ""
+o10 = false || varObject // f || object вернёт varObject
+```
+
+> **Примечание:** Если вы используете этот оператор, чтобы задать значение по умолчанию для некоторой переменной, имейте в виду, что любое _ложноподобное_ будет проигнорировано. Если вам нужно исключить только {{jsxref("null")}} или {{jsxref("undefined")}}, попробуйте воспользоваться [оператором нулевого слияния](/ru/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator).
+
+### Правила конвертации для булевых значений
+
+#### Конвертация И в ИЛИ
+
+Следующая операция с **булевыми значениями**:
+
+```js
+bCondition1 && bCondition2
+```
+
+всегда эквивалентна:
+
+```js
+!(!bCondition1 || !bCondition2)
+```
+
+#### Конвертация ИЛИ в И
+
+Следующая операция с **булевыми значениями**:
+
+```js
+bCondition1 || bCondition2
+```
+
+всегда эквивалентна:
+
+```js
+!(!bCondition1 && !bCondition2)
+```
+
+### Удаление вложенных круглых скобок
+
+Поскольку логические выражения вычисляются слева направо, всегда можно удалить круглые скобки из сложного выражения при условии соблюдения определенных правил.
+
+Следующая составная операция с **булевыми значениями**:
+
+```js
+bCondition1 && (bCondition2 || bCondition3)
+```
+
+всегда эквивалентна:
+
+```js
+!(!bCondition1 || !bCondition2 && !bCondition3)
+```
+
+## Спецификации
+
+{{Specifications}}
+
+## Поддержка браузерами
+
+{{Compat}}
+
+## Смотрите также
+
+- [Оператор нулевого слияния (`??`)](/ru/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator)
+- {{jsxref("Boolean")}}
+- {{Glossary("Truthy")}}
+- {{Glossary("Falsy")}}