⚡ JavaScript

Операторы сравнения и логические операторы — JavaScript

Урок 5 / 35 • Полная теория для чтения

Что это и зачем?

Представь, что ты — робот, который выполняет команды. Чтобы принимать решения, тебе нужно уметь сравнивать вещи и проверять условия. Например:

Сравнение: «У тебя есть 100 рублей?» (ты сравниваешь свои деньги с числом 100).
Логика: «У тебя есть 100 рублей И ты не голоден?» (проверяешь два условия сразу).

В JavaScript операторы сравнения и логические операторы помогают компьютеру отвечать на такие вопросы. Результатом всегда будет true (правда) или false (ложь). Это как светофор: зелёный — можно ехать (true), красный — стой (false).

Зачем это нужно? Без них программы были бы скучными — они бы просто выполняли команды по порядку. А с ними программа может реагировать на разные ситуации: например, если пользователь ввёл правильный пароль — пустить его, если нет — выдать ошибку.

В Python эти операторы работают почти так же, но в JavaScript есть свои хитрости. Мы их разберём.

Примеры кода с объяснением

1. Базовые операторы сравнения: `>`, `<`, `>=`, `<=`

Самые простые — как на уроке математики. Сравниваем числа:

// Пример 1: Больше или меньше?
let возраст = 12;
let можноВойти = возраст >= 12; // Можно ли войти, если возраст 12 или больше?
console.log(можноВойти); // Выведет: true (потому что 12 >= 12 — правда)

// Пример 2: Сравнение с порогом
let температура = 30;
let жарко = температура > 25;   // Больше 25?
console.log(жарко); // true (30 > 25 — правда)

let холодно = температура < 10; // Меньше 10?
console.log(холодно); // false (30 не меньше 10)

// Пример 3: Строки тоже можно сравнивать!
console.log("арбуз" > "банан"); // false
// Почему? Буквы сравниваются по алфавиту: 'а' (1-я буква) меньше 'б' (2-я буква)
// В Python то же самое, но там чувствительность к регистру другая

Важно: В JavaScript строки сравниваются по коду Unicode (как в таблице). «а» меньше «я», а «А» меньше «а». Это как словарь: сначала идут заглавные буквы, потом строчные.

2. Операторы равенства: `==` и `===`

Тут начинается самое интересное! В JavaScript есть два способа проверить, равны ли значения:

== — «нестрогое равенство» (сравнивает значения, но может преобразовывать типы)
=== — «строгое равенство» (сравнивает и значение, и тип данных)

// Пример 4: Сравнение чисел и строк
let число = 5;
let строка = "5";

console.log(число == строка);   // true — потому что 5 равно 5 (JavaScript преобразовал строку в число)
console.log(число === строка);  // false — потому что число (number) не равно строке (string)!

// В Python такого нет: "5" == 5 даст False сразу, без преобразования

// Пример 5: Сравнение с true/false
console.log(1 == true);  // true — потому что true преобразуется в 1
console.log(1 === true); // false — разные типы (число vs boolean)

console.log(0 == false); // true
console.log(0 === false); // false

// Пример 6: Пустые значения
console.log(null == undefined); // true — специальное правило JS
console.log(null === undefined); // false — разные типы

// В Python нет undefined, есть только None, и он не равен ничему, кроме самого себя

Совет для новичков: Всегда используй === (строгое равенство), чтобы избежать сюрпризов. Это как в математике: 5 и «5» — это разные вещи, хоть и выглядят похоже.

3. Логический оператор `&&` (И)

Оператор «И» (AND) возвращает true только если оба условия истинны. В жизни это как: «Я пойду гулять, если сделаю уроки И мама разрешит».

// Пример 7: Проверка двух условий
let возраст = 14;
let естьБилет = true;

let можно_в_кино = (возраст >= 12) && (естьБилет === true);
console.log(можно_в_кино); // true — возраст подходит И билет есть

// Если бы возраст был 10:
возраст = 10;
можно_в_кино = (возраст >= 12) && (естьБилет === true);
console.log(можно_в_кино); // false — первое условие ложно, второе истинно, но И требует оба

// Пример 8: Сложное условие
let оценка = 4;
let поведение = "отлично";

let похвалят = (оценка === 5) && (поведение === "отлично");
console.log(похвалят); // false — оценка не 5, хотя поведение отличное

// В Python пишется так же: and

Лайфхак: JavaScript «ленится» — если первое условие в && ложно, он даже не проверяет второе. Это называется «короткое замыкание». Экономим время!

4. Логический оператор `||` (ИЛИ)

Оператор «ИЛИ» (OR) возвращает true, если хотя бы одно условие истинно. Как в жизни: «Я пойду гулять, если сделаю уроки ИЛИ если на улице солнце».

// Пример 9: Выбор из двух вариантов
let естьДеньги = false;
let естьПодарок = true;

let можно_купить_игру = естьДеньги || естьПодарок;
console.log(можно_купить_игру); // true — денег нет, но есть подарок (одно условие истинно)

// Пример 10: Проверка возраста
let возрастПользователя = 17;
let входРазрешен = (возрастПользователя >= 18) || (возрастПользователя >= 16 && естьБилет);
// Если возраст >=18 ИЛИ (возраст >=16 И есть билет)
console.log(входРазрешен); // false — 17 не >=18, и хотя 17>=16, но естьБилет не задан (undefined — это false)

// Пример 11: Значения по умолчанию
let имя = "";
let отображаемоеИмя = имя || "Гость";
console.log(отображаемоеИмя); // "Гость" — потому что пустая строка считается false

// В Python: имя or "Гость" — работает так же

Хитрость: || тоже «ленится» — если первое условие истинно, второе не проверяется. Это используют для установки значений по умолчанию.

5. Логический оператор `!` (НЕ)

Оператор «НЕ» (NOT) просто переворачивает значение: true становится false, и наоборот. Как волшебное слово «не» в русском языке.

// Пример 12: Простое отрицание
let светВключен = true;
console.log(!светВключен); // false — свет включен, НЕ свет — это выключен

// Пример 13: Проверка, что НЕ равно
let пароль = "1234";
let правильныйПароль = "5678";

if (пароль !== правильныйПароль) { // !== — это "строго не равно"
    console.log("Пароль неверный!"); // Выполнится, потому что "1234" !== "5678"
}

// Пример 14: Двойное отрицание (!!)
let значение = 0;
console.log(!!значение); // false — 0 в JS считается false, !! превращает в false
// Это способ быстро превратить любое значение в true/false

// В Python: not — то же самое, но нет двойного отрицания как в JS

Внимание: В JavaScript есть оператор != (не равно, нестрогий) и !== (строго не равно). Аналогично == и ===. Всегда используй !== для надёжности.

6. Комбинирование операторов

Настоящая магия начинается, когда мы смешиваем все операторы вместе. Как в математике: сначала умножение, потом сложение. В логике свой порядок:

! (НЕ) — выполняется первым
&& (И) — вторым
|| (ИЛИ) — третьим

// Пример 15: Сложное условие с приоритетом
let возраст = 20;
let естьПрава = true;
let трезвый = false;

// Можно ли сесть за руль?
let можно_за_руль = (возраст >= 18) && естьПрава && трезвый;
console.log(можно_за_руль); // false — все true, но трезвый = false

// А если мы используем скобки, порядок меняется:
let странноеПравило = возраст >= 18 && (естьПрава || трезвый);
// Сначала ИЛИ в скобках: естьПрава || трезвый = true || false = true
// Потом И: возраст >= 18 && true = true && true = true
console.log(странноеПравило); // true — потому что права есть, а трезвость не важна

// Пример 16: Проверка на високосный год
let год = 2024;
let високосный = (год % 4 === 0) && (год % 100 !== 0) || (год % 400 === 0);
// % — это остаток от деления (mod)
console.log(високосный); // true — 2024 делится на 4, но не на 100 (или делится на 400)

// Пример 17: Игра «Угадай число»
let секретноеЧисло = 7;
let попытка = 5;

let результат = (попытка > 0) && (попытка === секретноеЧисло);
console.log(результат); // false — попытка > 0 (true), но 5 !== 7 (false) → true && false = false

// С отрицанием:
let неУгадал = !(попытка === секретноеЧисло);
console.log(неУгадал); // true — потому что !false = true

Важно: Всегда используй скобки ( ) для сложных условий, даже если знаешь приоритет. Это делает код понятнее и для тебя, и для других программистов.

Типичные ошибки

Ошибка 1: Путаница между `=` и `==`

Одна из самых частых ошибок у новичков:

= — это присваивание (положить значение в переменную)
== или === — это сравнение (проверить, равны ли значения)

// Неправильно:
if (возраст = 18) { // Ошибка! Здесь присваивание, а не сравнение!
    console.log("Тебе 18 лет");
}
// Этот код сделает возраст равным 18 и условие будет true (потому что 18 — истинное значение)

// Правильно:
if (возраст === 18) {
    console.log("Тебе 18 лет");
}

// В Python такая ошибка вызовет синтаксическую ошибку, а в JS — нет!

Ошибка 2: Забываем про типы данных

Новички часто думают, что "5" и 5 — это одно и то же. В JavaScript — не всегда:

let число = 5;
let строка = "5";

console.log(число + строка); // "55" — сложение числа и строки даёт строку! (конкатенация)
console.log(число == строка); // true — нестрогое равенство
console.log(число === строка); // false — строгое равенство

// Моя любимая ошибка:
console.log(0 == false);  // true — 0 считается ложным
console.log("" == false); // true — пустая строка тоже ложная
console.log([] == false); // true — пустой массив... тоже! (сложная тема)

// Поэтому используйте === всегда!

Ошибка 3: Неправильный приоритет операторов

Без скобок можно получить неожиданный результат:

// Хотели: (возраст > 10) И (возраст < 20)
let возраст = 25;
let результат = возраст > 10 && возраст < 20; // Правильно: true && false = false

// А что если написать так?
результат = возраст > 10 && возраст < 20 || возраст > 30;
// Из-за приоритета это будет: (возраст > 10 && возраст < 20) || возраст > 30
// = (true && false) || false = false || false = false

// Но если забыть скобки:
результат = возраст > (10 && возраст < 20) || возраст > 30; // Ошибка!
// 10 && возраст < 20 = 10 && true = true (так как 10 — истинное число)
// возраст > true = 25 > 1 = true
// true || false = true — совсем не то, что ожидали!

Ошибка 4: Сравнение с `NaN`

NaN — это специальное значение «не число» (Not a Number). Оно не равно самому себе!

let результат = 0 / 0; // NaN (деление нуля на ноль)
console.log(результат === NaN); // false! Никогда не сравнивайте с NaN так

// Правильный способ:
console.log(isNaN(результат)); // true — специальная функция

// В Python: math.isnan() — то же самое

Ошибка 5: Использование присваивания в условиях

Иногда новички пишут так, думая, что это сравнение:

// Очень опасная ошибка:
let x = 10;
if (x = 5) { // Здесь x становится 5, и условие true (5 — истина)
    console.log("x равен 5"); // Выполнится всегда!
}

// Как защититься? Можно писать значение слева:
if (5 = x) { // Ошибка! Нельзя присвоить 5 переменной x таким образом
    // JavaScript выдаст ошибку
}

// Лучший способ — всегда использовать ===

Ошибка 6: Путаница между `&&` и

← Предыдущая Арифметические операции — JavaScript Вперёд → Ввод и вывод данных в JavaScript (Node.js): подроб

Операторы сравнения и логические операторы — JavaScript

Что это и зачем?

Примеры кода с объяснением

1. Базовые операторы сравнения: >, <, >=, <=

2. Операторы равенства: == и ===

3. Логический оператор && (И)

4. Логический оператор || (ИЛИ)

5. Логический оператор ! (НЕ)