---
title: "Логические операторы"
description: "Объединяем несколько простых условий в одно сложное."
url: "https://doka.guide/js/logic-operators/"
section: "JavaScript"
createdAt: "2021-06-14"
updatedAt: "2026-11-20"
baseline: [{"group":"javascript","features":["javascript.operators.logical_and","javascript.operators.logical_or","javascript.operators.logical_not"]}]
authors: ["nlopin"]
contributors: ["furtivite"]
related: ["js/if-else", "js/for", "js/array-find"]
source: "https://github.com/doka-guide/content/blob/main/js/logic-operators/index.md"
license: "CC BY-NC-SA 4.0"
---

# Логические операторы

## Кратко

Логические операторы помогают составлять сложные логические условия, которые часто нужны при ветвлении с помощью [`if...else`](/js/if-else/).

<aside>

❗ При сравнении объектов, массивов и функций, важно учесть их особенность, так как результат сравнения таких типов данных может быть непредсказуемым. Подружиться с особенностями можно в статье «[Хранение по ссылке и по значению](/js/ref-type-vs-value-type/)».

</aside>

## Как пишется

### И, `&&`

Интернет-магазин показывает цены со скидкой только зарегистрированному пользователю, сделавшему больше одной покупки.

В описании два условия, которые должны одновременно быть верными:

- пользователь должен быть зарегистрирован;
- количество покупок должно быть больше одной.

Если одно из условий, или оба сразу неверны, то цену показывать не нужно.

Именно по такому принципу работает оператор логическое И, пишется `&&`. Если соединить с его помощью два выражения, то результат будет равен истине только тогда, когда оба выражения истинны:

```js
if (isRegistered === true && orders > 1) {
  // Показываем цены
}
```

<iframe title="Логическое И" src="https://doka.guide/js/logic-operators/demos/Lopinopulos-wLGJgz/" height="150"></iframe>

Обычно для того, чтобы понять, как работают логические операторы, рисуют таблицу истинности. В ячейках — итоговое значение операции при соответствующих операндах:

<div class="article__table article__table_all-third">

| `&&`    |  `true` | `false` |
|---------|--------:|--------:|
| `true`  |  `true` | `false` |
| `false` | `false` | `false` |

</div>

### ИЛИ, `||`

Представьте, что мы проверяем билеты на концерт. Пропускать нужно людей с билетами, а также тех, кто находится в списке приглашённых. Выполнение любого из этих условий гарантирует попадание на концерт.

Чтобы написать такое составное условие, воспользуйтесь оператором логического ИЛИ, обозначается как две вертикальные черты `||`. Логическое или вернёт `true`, если хотя бы одно из условий `true`.

Генерируйте гостей в демо и смотрите, как отрабатывает условие, которое записано так:

```js
if (hasTicket || isInvited) { ... }
```

<iframe title="Логическое ИЛИ" src="https://doka.guide/js/logic-operators/demos/Lopinopulos-VJjboW/" height="300"></iframe>

<div class="article__table article__table_all-third">

| `\|\|`  | `true` | `false` |
| ------- | -----: | ------: |
| `true`  | `true` |  `true` |
| `false` | `true` | `false` |

</div>

### НЕ `!`

Оператор «логическое НЕ» превращает `true` в `false` и наоборот.

Он записывается в виде восклицательного знака `!` перед операндом: `!операнд`. Чаще всего это переменная. Например, `!myVariable`. Операторы, которые производят операцию над одним операндом, называются унарными.

Например, мы можем предлагать купить билет посетителю без билета:

```js
if (!hasTicket) {
  // Купи билет, дорогой!
}
```

## На практике: Сергей Минаков

🛠 Оператор «ИЛИ» (`||`) можно использовать для установки значения по умолчанию. Для этого используйте следующую конструкцию:

```js
value = value || 'Значение по умолчанию'
```

Или можно использовать сокращённый вариант:

```js
value ||= 'Значение по умолчанию'
```

<aside>

❗ Если в переменную записать [`undefined`](/js/undefined/), [`null`](/js/null-primitive/), `NaN`, `0`, пустую строку или любое другое значение, которое JavaScript может привести к `false`, то данная конструкция перезапишет его значением по умолчанию.

</aside>

В следующем примере пользователь может выбрать поисковый движок и записать его в переменную, или отказаться от этого. Тогда мы по умолчанию установим ему Google.

```js
let searchEngine1 = 'Яндекс'
let searchEngine2

searchEngine1 = searchEngine1 || 'Google'
searchEngine2 = searchEngine2 || 'Google'

console.log(searchEngine1)
// Яндекс

console.log(searchEngine2)
// Google (значение по умолчанию)
```

Такой способ работает из-за особенности оператора «ИЛИ». Он не приводит значения к [типу `Boolean`](/js/boolean/), а просто возвращает то, что стоит левее или правее.

- Если левое значение можно привести к `true`, оператор возвращает левое значение.
- Если левое значение можно привести к `false`, оператор возвращает правое значение.

```js
console.log(null || 0)
// 0

console.log(0 || null)
// null

console.log('Собака' || 'Кошка')
// Собака
```

В последнем примере JavaScript приводит левое значение к типу `Boolean` и получает `true`, из-за чего решает вернуть именно его (`'Собака'`), а на правое даже не смотрит.

🛠 Оператор «И» (`&&`) можно использовать в [React-компонентах](/tools/react-and-alternatives/), когда мы хотим что-то показать или спрятать в зависимости от определённого условия. Для этого нужно воспользоваться следующей jsx-конструкцией:

```jsx
<>
  {
    condition &&
    <p>
      Если condition == true,
      то показываем этот текст.
    </p>
  }
</>
```

Давайте напишем небольшой компонент, который будет выводить секретное сообщение только тем пользователям, которые ввели правильный пароль:

```jsx
import React, { useState } from 'react'

export default function App() {
  const [password, setPassword] = useState('')

  return (
    <>
      <h1>Введите пароль, чтобы увидеть секрет</h1>

      <label>
        <span>Пароль</span>
        <input
          type="password"
          value={password}
          onChange={(e) => setPassword(e.target.value)}
        />
      </label>

      {
        password === '123456' &&
        <p>Секрет: Дока — сокращение от «документация»</p>
      }
    </>
  )
}
```

Такой способ работает из-за того, что оператор «И» не приводит значения к [типу `Boolean`](/js/boolean/), а просто возвращает то, что стоит левее или правее.

- Если левое значение можно привести к `true`, то оператор возвращает правое значение.
- Если левое значение можно привести к `false`, то оператор возвращает левое значение.

```js
console.log(null && 0)
// null

console.log(0 && null)
// 0

console.log('Лево' && 'Право')
// Право
```

JavaScript приводит левое значение к типу `Boolean` и получает `true`, из-за чего решает вернуть правое значение (`'Право'`).

🛠 Двойное отрицание (`!!`) можно использовать, если хотим привести значение к [логическому типу данных](/js/boolean/). Такой же результат получится, если использовать функцию `Boolean`.

```js
const value = 'Непустая строка'

console.log(Boolean(value))
// true

console.log(!!value)
// true
```

