Автор: Рябкова Анна, Коптикова Лилия, Шевчук Александра

Что такое условия в программировании

Условия — это механизм, который позволяет программе принимать решения в зависимости от заданных условий. Они работают по принципу: «если выполняется условие — выполняем один блок кода, иначе — другой». Условия основаны на логических выражениях, которые могут быть истинными (true) или ложными (false). В зависимости от результата программа выбирает, какой код выполнить дальше.

Зачем они нужны и где применяются

Условные конструкции являются одной из фундаментальных концепций в программировании. Они позволяют программе принимать решения на основе определенных условий, что делает код более гибким и адаптивным. Например:

Валидация данных — проверка корректности введённой информации.
Игры и анимации — определение поведения объектов.
Алгоритмы и логика — принятие решений в алгоритмах.
Фильтрация данных — отбор нужных элементов из массива или базы данных.

Операторы сравнения

Основные операторы

В JavaScript операторы сравнения записываются так:

Больше/меньше: a > b, a < b.
Больше/меньше или равно: a >= b, a <= b.
Равно: a == b (нестрогое сравнение) и a === b (строгое сравнение).
Не равно: a != b и a !== b.

Сравнение строк и разных типов данных

При сравнении строк используется лексикографический порядок. При сравнении разных типов значений JavaScript приводит их к числу. Например:

console.log("2" > 1); // true
console.log(true == 1); // true

Однако строгие операторы (=== и !==) не выполняют приведение типов, что делает код более предсказуемым.

Сравнение `null` и `undefined`

null == undefined — true, но null === undefined — false.
При использовании математических операторов null преобразуется в 0, а undefined — в NaN.

Сравнение с `NaN`

NaN не равно самому себе:

console.log(NaN == NaN); // false
console.log(NaN === NaN); // false

NaN всегда возвращает false при сравнении с чем-либо, включая самого себя.
Поэтому, чтобы проверить, является ли значение NaN, нужно использовать isNaN() или Number.isNaN():
```
console.log(isNaN(NaN)); // true
console.log(isNaN("hello")); // true (не число → NaN)
console.log(Number.isNaN(NaN)); // true
console.log(Number.isNaN("hello")); // false (строка не является числом, но и не NaN)
```

Любая арифметическая операция с NaN возвращает NaN:

console.log(NaN + 5); // NaN
console.log(NaN * 2); // NaN
console.log(NaN / 10); // NaN
console.log(NaN - NaN); // NaN

typeof NaN возвращает "number", несмотря на то, что это не число по смыслу:
```
console.log(typeof NaN); // "number"
```

✅ Как правильно проверять `NaN`?

Используйте Number.isNaN(), так как isNaN() может преобразовывать другие типы в NaN:

console.log(isNaN("123abc")); // true (преобразуется в NaN)
console.log(Number.isNaN("123abc")); // false (строка не является NaN)

⚠ Запомните: NaN — единственное значение в JavaScript, которое не равно самому себе!

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

Логические операторы в JavaScript используются для изменения или комбинирования логических значений. Они часто применяются в условиях (if, while) и для упрощения выражений.

🔹 Основные логические операторы:

&& (И)
|| (ИЛИ)
! (НЕ)
?? (нулевой оператор присваивания)
&&= (логическое присваивание И)
||= (логическое присваивание ИЛИ)
??= (нулевое присваивание)

🔹 Оператор `&&` (И)

Оператор && (логическое И) возвращает первый false-подобный операнд или последний, если все истинные.

console.log(true && false); // false
console.log(1 && 0); // 0
console.log(5 && "hello"); // "hello" (оба истинные, вернёт последний)
console.log(null && "world"); // null (останавливается на первом `false`)

📌 Как работает?

Если оба операнда истинны, возвращается второй операнд.
Если один из операндов ложен, возвращается первый ложный.

🔹 Оператор `||` (ИЛИ)

Оператор || (логическое ИЛИ) возвращает первый true-подобный операнд или последний, если все ложные.

console.log(false || true); // true
console.log(0 || "hello"); // 'hello' (вернёт первый истинный)
console.log("" || 0 || null || "JavaScript"); // "JavaScript" (первый истинный)
console.log(null || undefined); // undefined (оба ложные, вернёт последний)

📌 Как работает?

Если хотя бы один операнд истинен, возвращается первый истинный.
Если оба операнда ложны, возвращается последний ложный.

🔹 Оператор `!` (НЕ)

Оператор ! (логическое НЕ) инвертирует логическое значение.

console.log(!true); // false
console.log(!0); // true
console.log(!"hello"); // false (строка — это `true`-значение)

📌 Как работает?

!true → false
!false → true
!0 → true (0 — ложное значение)
!"" → true (пустая строка — ложное значение)
!null → true

Можно использовать !! (двойное отрицание) для приведения к логическому типу:

console.log(!!"hello"); // true
console.log(!!0); // false

🔹 Оператор `??` (нулевой оператор присваивания)

Оператор ?? (нулевое слияние) возвращает первый НЕ null и НЕ undefined операнд.

console.log(null ?? "default"); // "default"
console.log(undefined ?? 42); // 42
console.log(0 ?? 100); // 0 (не `null`, поэтому возвращается сам 0)

📌 Как работает?

Если первый операнд null или undefined, возвращается второй.
Если первый операнд НЕ null и НЕ undefined, возвращается он сам.

⚠ Отличие от ||:
|| проверяет ложные значения (0, "", false), а ?? — только null и undefined!

console.log(0 || 100); // 100 (0 считается ложным)
console.log(0 ?? 100); // 0 (0 НЕ `null` и НЕ `undefined`)

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

✅ `&&=` (логическое присваивание И)

Присваивает значение, только если переменная уже истинна.

let a = true;
a &&= "Привет";
console.log(a); // "Привет"

let b = 0;
b &&= "Мир";
console.log(b); // 0 (присваивание не произошло)

✅ `||=` (логическое присваивание ИЛИ)

Присваивает значение, если переменная ложная.

let c = 0;
c ||= 100;
console.log(c); // 100

let d = "JavaScript";
d ||= "Python";
console.log(d); // "JavaScript" (присваивание не произошло)

✅ `??=` (нулевое присваивание)

Присваивает значение, если переменная null или undefined.

let e = null;
e ??= "Значение по умолчанию";
console.log(e); // "Значение по умолчанию"

let f = "";
f ??= "Python";
console.log(f); // "" (пустая строка НЕ `null` и НЕ `undefined`)

Приоритет выполнения логических операторов

При использовании нескольких операторов одновременно учитывайте приоритет операторов.

! (НЕ)
&& (И)
|| (ИЛИ)

Операторы с более высоким приоритетом выполняются раньше.

Полный список приоритетов операторов можно найти в официальной документации:
MDN: Operator Precedence

Использование в условиях `if`, `while`

Оператор && можно использовать для сокращения кода:

if (x > 0 && y > 0) {
    console.log("Обе переменные положительные");
}

Оператор || используется для установки значений по умолчанию:

let name = userName || "Гость";

✅ Как это работает?

let name = userName || "Гость";
console.log(name);

🔹 Если userName содержит истинное значение (например, "Иван"), переменная name получит его.
🔹 Если userName ложное ("", 0, null, undefined, false), то name примет "Гость".

📌 Примеры работы:

console.log("" || "Гость"); // "Гость" (пустая строка — ложное значение)
console.log(0 || 100); // 100 (ноль — ложное значение)
console.log(null || "default"); // "default" (`null` — ложное)
console.log("Иван" || "Гость"); // "Иван" (истинное значение)

⚠ Проблема с `||`: ложные значения

Оператор || считает ложными:

0
"" (пустую строку)
false
null
undefined
NaN

⚠ Иногда 0 или "" могут быть допустимыми значениями, но || их заменит.

Пример ошибки:

let port = 0 || 3000;
console.log(port); // 3000 (но 0 мог быть корректным значением!)

✅ Альтернатива: `??` (нулевой оператор присваивания)

Чтобы избежать замены 0 или "", используйте ?? (нулевое слияние), который проверяет только null и undefined:

let port = 0 ?? 3000;
console.log(port); // 0 (не заменяется)

📌 Разница || и ??:

console.log(0 || 100); // 100 (0 считается ложным)
console.log(0 ?? 100); // 0 (0 НЕ `null` и НЕ `undefined`)

Условные конструкции

if, else if, else - базовый синтаксис

Инструкция `if`

Инструкция if(...) вычисляет условие в скобках и, если результат true, то выполняет блок кода.

Пример:

let year = 2015;
if (year == 2015) {
    console.log("Верно!");
}

Если нужно выполнить несколько инструкций, используйте фигурные скобки:

if (year == 2015) {
    console.log("Верно!");
    console.log("Отличный год!");
}

Использование фигурных скобок {} всегда улучшает читаемость кода.

Преобразование к логическому типу

Выражения в if приводятся к логическому значению:

0, "", null, undefined, NaN → false
Остальные значения → true

if (0) {
    // Не выполнится
    console.log("Это не выполнится");
}

if ("hello") {
    // Выполнится
    console.log("Привет!");
}

Блок `else`

Блок else выполняется, если условие в if ложно:

if (year == 2015) {
    console.log("Верно!");
} else {
    console.log("Неверно!");
}

Несколько условий: `else if`

Если условий несколько, используйте else if:

if (year < 2015) {
    console.log("Слишком рано");
} else if (year > 2015) {
    console.log("Слишком поздно");
} else {
    console.log("Верно!");
}

Тернарный оператор `?`

Упрощает условные выражения:

let access = age >= 18 ? "Доступ разрешен" : "Доступ запрещен";
console.log(access);

`switch` - альтернатива `if`

Конструкция switch удобна для сравнения с разными значениями:

let fruit = "яблоко";
switch (fruit) {
    case "банан":
        console.log("Это банан");
        break;
    case "яблоко":
        console.log("Это яблоко");
        break;
    default:
        console.log("Неизвестный фрукт");
}

Группировка `case`

Можно объединять несколько case:

switch (fruit) {
    case "апельсин":
    case "мандарин":
        console.log("Это цитрусовый фрукт");
        break;
    default:
        console.log("Неизвестный фрукт");
}

Важные особенности

switch использует строгое сравнение ===.
Если нет break, выполнение продолжается до следующего case.

Пример без break:

let num = 2;
switch (num) {
    case 1:
        console.log("Один");
    case 2:
        console.log("Два");
    case 3:
        console.log("Три");
}
// Выведет "Два" и "Три".

Операторы сравнения

== и === - в чем разница

== — нестрогое равенство, приводит операнды к общему типу.
=== — строгое равенство, сравнивает значения без приведения типов.

Пример:

console.log(0 == false); // true (приведение типов)
console.log(0 === false); // false (разные типы)

!= и !== - строгие и нестрогие неравенства

!= — нестрогое неравенство, приводит операнды к числу.
!== — строгое неравенство, сравнивает без приведения типов.

console.log(1 != "1"); // false (приведение типов)
console.log(1 !== "1"); // true (разные типы)

>, <, >=, <= - стандартные операторы сравнения

Эти операторы работают аналогично математическим сравнениям.

console.log(5 > 3); // true
console.log(5 <= 5); // true

Как работают сравнения строк

Строки сравниваются посимвольно в лексикографическом порядке:

console.log("яблоко" > "апельсин"); // true, потому что 'я' > 'а'

Алгоритм:

Сравниваются первые символы.
Если они равны — сравниваются следующие.
Более длинная строка считается большей, если её начало совпадает с другой.

Сравнение разных типов данных

При сравнении разных типов JavaScript приводит их к числу:

console.log("2" > 1); // true
console.log(true == 1); // true

Строгое сравнение (`===` и `!==`)

=== не выполняет приведение типов.
!== тоже сравнивает без приведения типов.

console.log("0" === 0); // false
console.log(null === undefined); // false

Как избежать ошибок при сравнении

Используйте === и !==, чтобы избежать неожиданных преобразований.
Будьте осторожны при сравнении с null и undefined.
Не используйте >=, >, <, <= с null и undefined, если не уверены в логике.

Заключение

🔹 Условные конструкции позволяют программам принимать решения, делая код более динамичным и адаптивным.
🔹 Операторы сравнения (==, ===, !=, !==, >, <, >=, <=) помогают анализировать данные, но важно понимать различия между строгим и нестрогим сравнением.
🔹 Логические операторы (&&, ||, !, ??) позволяют комбинировать условия, а также использовать фолбэк значений и логическое присваивание.
🔹 Тернарный оператор (?) помогает писать компактные условия.
🔹 Конструкция switch удобна для обработки множества вариантов значений.

⚠ Будьте внимательны!

Используйте === и !==, чтобы избежать неожиданного приведения типов.
NaN не равен даже самому себе – проверяйте его с Number.isNaN().
|| заменяет все ложные значения (0, "", false), а ?? проверяет только null и undefined.
Сравнение строк выполняется по Unicode-кодам символов, а разные типы преобразуются в число перед сравнением.

JS. Начало #2. Ветвление

Что такое условия в программировании

Зачем они нужны и где применяются

Операторы сравнения

Основные операторы

Сравнение строк и разных типов данных

Сравнение null и undefined

Сравнение с NaN

✅ Как правильно проверять NaN?

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

🔹 Основные логические операторы:

🔹 Оператор && (И)

🔹 Оператор || (ИЛИ)

🔹 Оператор ! (НЕ)

🔹 Оператор ?? (нулевой оператор присваивания)

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

✅ &&= (логическое присваивание И)

✅ ||= (логическое присваивание ИЛИ)

✅ ??= (нулевое присваивание)

Приоритет выполнения логических операторов

Использование в условиях if, while

✅ Как это работает?

⚠ Проблема с ||: ложные значения

✅ Альтернатива: ?? (нулевой оператор присваивания)

Условные конструкции

if, else if, else - базовый синтаксис

Инструкция if

Преобразование к логическому типу

Блок else

Несколько условий: else if

Тернарный оператор ?

switch - альтернатива if

Группировка case

Важные особенности

Операторы сравнения

== и === - в чем разница

!= и !== - строгие и нестрогие неравенства

>, <, >=, <= - стандартные операторы сравнения

Как работают сравнения строк

Сравнение разных типов данных

Строгое сравнение (=== и !==)

Как избежать ошибок при сравнении

Заключение

Сравнение `null` и `undefined`

Сравнение с `NaN`

✅ Как правильно проверять `NaN`?

🔹 Оператор `&&` (И)

🔹 Оператор `||` (ИЛИ)

🔹 Оператор `!` (НЕ)

🔹 Оператор `??` (нулевой оператор присваивания)

✅ `&&=` (логическое присваивание И)

✅ `||=` (логическое присваивание ИЛИ)

✅ `??=` (нулевое присваивание)

Использование в условиях `if`, `while`

⚠ Проблема с `||`: ложные значения

✅ Альтернатива: `??` (нулевой оператор присваивания)

Инструкция `if`

Блок `else`

Несколько условий: `else if`

Тернарный оператор `?`

`switch` - альтернатива `if`

Группировка `case`

Строгое сравнение (`===` и `!==`)