Логическое И (&&)
=================

Логический оператор И (`&&`) (конъюнкция) для набора операндов со значением типа `Boolean` будет `true` только в случае, если все операнды содержат значение `true`. В противном случае это будет `false`.

В целом, оператор вернёт значение первого ложноподобного операнда при вычислении, либо значение последнего операнда, если все операнды оказались истиноподобными.

Интерактивный пример
--------------------

Синтаксис
---------


```js
expr1 && expr2;
```

Описание
--------

Логическое И (`&&`) вычисляет операнды слева направо, возвращая сразу значение первого попавшего ложноподобного операнда; если все значения истиноподобны, возвращается значение последнего операнда.

Если значение может быть преобразовано в `true`, то оно рассматривается как истиноподобное (truthy). Если же значение может быть преобразовано в `false`, то оно называется ложноподобным (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
```


 Несмотря на то, что оператор `&&` может использоваться с операндами, не содержащие логических значений, он всё равно останется булевым оператором, поскольку его возвращаемое значение всегда можно преобразовать в булевый примитив.
 Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной `оператор НЕ` или конструктор `Boolean` (en-US).

### Сокращённое вычисление

 Оператор логического И вычисляет выражение по сокращённой схеме.
 Каждый операнд приводится к булевому значению, если результат одного преобразования оказывается `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
```

### Приоритет операторов

Оператор И имеет более высокий приоритет, чем оператор ИЛИ, поэтому оператор `&&` выполнится раньше оператора `||` (см. приоритет операторов).


```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);
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # prod-LogicalANDExpression |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Boolean`
* Truthy
* Falsy