Тип boolean в TypeScript

Пример: Объявление boolean переменных

// Явное объявление
let isActive: boolean = true;
let isDeleted: boolean = false;

// Через сравнение
let возраст: number = 25;
let совершеннолетний: boolean = возраст >= 18;  // true

letтемпература: number = -5;
let замёрз: boolean =температура < 0;  // true

// Через вызов функции
let массив: number[] = [1, 2, 3];
let пуст: boolean = массив.length === 0;  // false

console.log(isActive);       // true
console.log(совершеннолетний); // true
console.log(пуст);           // false

Зачем нужен тип boolean?

Булевы значения используются повсюду: проверка прав доступа, валидация форм, управление видимостью элементов, флаги состояний, результаты сравнений и многое другое. Это основа условной логики любого алгоритма.

Таблица операторов сравнения

Примеры сравнений

// Строгое сравнение (рекомендуется)
console.log(5 === 5);        // true
console.log(5 === "5");      // false (разные типы!)
console.log(null === undefined); // false

// Нестрогое сравнение (не рекомендуется)
console.log(5 == 5);         // true
console.log(5 == "5");       // true (приведение типов)
console.log(null == undefined); // true

// Сравнение строк (лексикографическое)
console.log("а" < "б");     // true
console.log("abc" < "abd"); // true

// Сравнение с null и undefined
console.log(null == undefined);  // true
console.log(null === undefined); // false
console.log(null == 0);         // false
console.log(null == "");        // false

Рекомендация

В TypeScript всегда используйте строгие операторы === и !==. Они не выполняют приведение типов, что делает код предсказуемым и безопаснее. TypeScript даже может выдать предупреждение при использовании ==.

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

Возвращает true только когда оба операнда true. Если хотя бы один false — результат false.

// Таблица истинности для &&
console.log(true && true);    // true
console.log(true && false);   // false
console.log(false && true);   // false
console.log(false && false);  // false

// Практический пример
let возраст: number = 25;
let естьЛицензия: boolean = true;

let можетВодить: boolean = возраст >= 18 && естьЛицензия;
console.log(можетВодить);  // true

// Проверка диапазона
letтемпература: number = 20;
let комфортная: boolean =температура >= 18 &&температура <= 25;
console.log(комфортная);  // true

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

Возвращает true когда хотя бы один операнд true. Только оба false дают результат false.

// Таблица истинности для ||
console.log(true || true);    // true
console.log(true || false);   // true
console.log(false || true);   // true
console.log(false || false);  // false

// Практический пример: проверка роли
letisAdmin: boolean = false;
letisSuperAdmin: boolean = true;

let можетРедактировать: boolean = isAdmin || isSuperAdmin;
console.log(можетРедактировать);  // true

// Значение по умолчанию
let имя: string = "" || "Гость";  // "Гость"
let язык: string = "ru" || "en";  // "ru"

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

Инвертирует булево значение: true становится false, и наоборот.

// Инверсия значения
console.log(!true);     // false
console.log(!false);    // true
console.log(!0);        // true (0 falsy → инвертируется)
console.log(!"hello");  // false (строка truthy)

// Двойная инверсия (!!) — преобразование в boolean
console.log(!!42);      // true
console.log(!!0);       // false
console.log(!!"");      // false
console.log(!!null);    // false

// Практический пример
let пользовательЗалогинен: boolean = true;
let нужно показатьФорму: boolean = !пользовательЗалогинен;
console.log(нужно_показатьФорму);  // false

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

// Сложное условие: проверка возраста и подписки
letвозраст: number = 25;
let подписка: string = "premium";

let можетСмотреть = 
  (возраст >= 18 && подписка === "premium") || 
  (возраст >= 12 && подписка === "basic");

console.log(можетСмотреть);  // true

// Порядок вычисления:
// 1. (25 >= 18 && "premium" === "premium") → (true && true) → true
// 2. (25 >= 12 && "basic" === "premium")   → (true && false) → false  
// 3. true || false → true

Примеры интерпретации

// Пустые строки — falsy
if ("") {
  console.log("Это не выполнится");
} else {
  console.log("Пустая строка falsy");  // ← это
}

// Непустые строки — truthy
if ("0") {
  console.log("Строка '0' truthy!");  // ← это
}

// Пустой массив — truthy!
if ([]) {
  console.log("Пустой массив truthy!");  // ← это!
}

// Число 0 — falsy
if (0) {
  console.log("Не выполнится");
} else {
  console.log("0 falsy");  // ← это
}

// Null и undefined — falsy
if (null) {
  console.log("Не выполнится");
} else {
  console.log("null falsy");  // ← это
}

Ловушка для новичков

Пустой массив [], пустой объект {} и строка "0" — это truthy значения! Не путайте их с пустой строкой "" и нулём 0.

// && — останавливается на первом falsy
console.log(false && console.log("не выполнится"));
// Вывод: false (console.log не вызывается)

// || — останавливается на первом truthy
console.log(true || console.log("не выполнится"));
// Вывод: true (console.log не вызывается)

// Практическое применение: безопасный доступ к свойствам
let пользователь = {
  имя: "Иван",
  адрес: {
    город: "Москва"
  }
};

// Без optional chaining
let город = пользователь && пользователь.адрес && пользователь.адрес.город;
console.log(город);  // "Москва"

// С optional chaining (современный способ)
let город2 = пользователь?.адрес?.город;
console.log(город2);  // "Москва"

Паттерн: Значение по умолчанию

// Старый способ (||)
let цвет = вводПользователя || "синий";

// Проблема: 0 и "" тоже falsy
let размер = 0 || 16;    // 16 (неожиданно!)
let отступ = "" || "10px"; // "10px"

// Современный способ (?? — nullish coalescing)
let размер2 = вводРазмера ?? 16;    // 0, если ввод 0
let отступ2 = вводОтступа ?? "10px"; // "", если ввод ""

// ?? возвращает правый операнд ТОЛЬКО если левый null/undefined
console.log(0 ?? 16);     // 0 (не null/undefined)
console.log(null ?? 16);   // 16
console.log(undefined ?? 16); // 16
console.log("" ?? "default"); // "" (не null/undefined)

Паттерн: Условный вызов функции

// Вызов функции только если значение существует
function обработатьДанные(данные: string): void {
  console.log(`Обработка: ${данные}`);
}

let данные: string | null = "привет";

// Безопасный вызов
данные && обработатьДанные(данные);  // "Обработка: привет"

// Современный способ (optional chaining)
данные?.includes && обработатьДанные(данные);

// Nullish coalescing для значений по умолчанию
let настройки = {
  тема: пользователь.тема ?? "светлая",
  язык: пользователь.язык ?? "ru",
  уведомления: пользователь.уведомления ?? true
};

// Способ 1: Функция Boolean()
console.log(Boolean(42));       // true
console.log(Boolean(0));        // false
console.log(Boolean("hello"));  // true
console.log(Boolean(""));       // false
console.log(Boolean(null));     // false
console.log(Boolean([]));       // true (пустой массив!)
console.log(Boolean({}));       // true (пустой объект!)

// Способ 2: Двойная инверсия (!!)
console.log(!!42);       // true
console.log(!!0);        // false
console.log(!!"hello");  // true
console.log(!!"");       // false
console.log(!![]);       // true

// Способ 3: Неявное преобразование в условии
if (42) {
  console.log("Число 42 truthy");
}

// Способ 4: Оператор сравнения
let значение: number = 5;
let результат: boolean = Boolean(значение);
let результат2: boolean = !!значение;
let результат3: boolean = значение !== 0 && значение !== null && значение !== undefined;

Пример 1: Валидация формы

interface ДанныеФормы {
  имя: string;
  email: string;
  пароль: string;
  возраст: number;
}

function валидироватьФорму(данные: ДанныеФормы): string[] {
  const ошибки: string[] = [];

  if (!данные.имя.trim()) {
    ошибки.push("Имя обязательно для заполнения");
  }

  if (!данные.email.includes("@")) {
    ошибки.push("Некорректный email");
  }

  if (данные.пароль.length < 8) {
    ошибки.push("Пароль должен быть не менее 8 символов");
  }

  if (данные.возраст < 0 || данные.возраст > 150) {
    ошибки.push("Некорректный возраст");
  }

  return ошибки;
}

const результат = валидироватьФорму({
  имя: "",
  email: "invalid",
  пароль: "123",
  возраст: 200
});

console.log(результат);
// ["Имя обязательно для заполнения", "Некорректный email", ...]

Пример 2: Флаги функциональности

interface ФлагиПриложения {
  тёмнаяТема: boolean;
  уведомления: boolean;
  языкРазработчика: boolean;
  экспериментальныеФункции: boolean;
}

let настройки: ФлагиПриложения = {
  тёмнаяТема: true,
  уведомления: false,
  языкРазработчика: true,
  экспериментальныеФункции: false
};

function применитьНастройки(настройки: ФлагиПриложения): void {
  if (настройки.тёмнаяТема) {
    document.body.classList.add("dark-theme");
  }

  if (!настройки.уведомления) {
    отключитьPushУведомления();
  }

  // Комбинированные условия
  if (настройки.языкРазработчика && настройки.экспериментальныеФункции) {
    включитьРежимОтладки();
  }
}

Пример 3: Фильтрация данных

interface Пользователь {
  имя: string;
  возраст: number;
  активен: boolean;
  email: string;
}

const пользователи: Пользователь[] = [
  { имя: "Иван", возраст: 25, активен: true, email: "ivan@mail.ru" },
  { имя: "Мария", возраст: 17, активен: true, email: "" },
  { имя: "Пётр", возраст: 30, активен: false, email: "petr@mail.ru" },
  { اسم: "Анна", возраст: 22, активен: true, email: "anna@mail.ru" }
];

// Фильтрация: активные пользователи старше 18 с email
const подходящие = пользователи.filter(п => 
  п.активен && п.возраст >= 18 && п.email.length > 0
);

console.log(подходящие.map(п => п.имя));  // ["Иван", "Анна"]

// Поиск первого подходящего
const первый = пользователи.find(п => 
  п.активен && п.возраст >= 18
);

console.log(первый?.имя);  // "Иван"

Пример 4: Режим отладки

let РЕЖИМ_ОТЛАДКИ: boolean = process.env.NODE_ENV === "development";

function логировать(сообщение: string, данные?: any): void {
  if (!РЕЖИМ_ОТЛАДКИ) return;

  console.log(`[DEBUG] ${сообщение}`, данные ?? "");
}

function отладочнаяИнформация(): void {
  if (РЕЖИМ_ОТЛАДКИ) {
    console.log("Дополнительная информация");
  }
}

// Условный рендеринг (React пример)
function Кнопка({ isAdmin, текст, onClick }) {
  return (
    <button 
      onClick={onClick}
      disabled={!isAdmin}
      className={isAdmin ? "admin-btn" : "user-btn"}
    >
      {isAdmin ? `🔧 ${текст}` : текст}
    </button>
  );
}

! (НЕ)