Условия и логика

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

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

const age = 17;
const price = 35;
const balance = 120;

console.log(age >= 18);          // → false: до совершеннолетия год
console.log(balance >= price);   // → true: денег хватает
console.log(balance - price);    // → 85: арифметика тоже работает
console.log(age !== 17);         // → false

let score = 5;
console.log(score === 7);  // → false: просто вопрос, score не меняется
score = 7;                  // присваивание: теперь в score лежит 7
console.log(score === 7);  // → true

Сравнение строк: по алфавиту, но с оговорками

Строки сравниваются «по словарю», буква за буквой. Но компьютер сравнивает не буквы, а их внутренние номера (коды) в таблице Unicode. Поэтому есть два подвоха: заглавные буквы «меньше» строчных, а числа-строки сравниваются как текст, а не как числа.

console.log("Аня" < "Бахтиёр");  // → true: «А» стоит в алфавите раньше «Б»
console.log("а" < "Б");          // → false: строчная «а» в таблице после заглавной «Б»
console.log("Z" < "a");          // → true: все заглавные идут раньше строчных
console.log("10" < "9");         // → true: как текст «1» раньше «9», как в словаре
console.log(10 < 9);             // → false: а вот как числа

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

Когда с одной стороны > или < стоит строка, а с другой число, JavaScript превращает строку в число (вы видели это в уроке про приведение типов) и только потом сравнивает.

console.log("10" > 9);        // → true: строка "10" стала числом 10
console.log("abc" > 1);       // → false: "abc" стало NaN, а любое сравнение с NaN даёт false
console.log(NaN === NaN);      // → false: NaN не равно даже самому себе
console.log(null > 0);        // → false
console.log(null === 0);       // → false
console.log(null >= 0);       // → true — странность языка, к ней вернёмся в следующем разделе

Читать подробнее: learn.javascript.ru: Операторы сравнения · MDN: Сравнение и равенство

const age = 17;

// четыре строки console.log с оператором сравнения в каждой

false
true
false
false

// Впишите прогноз: true или false для каждого сравнения (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", ""];
const actual = [
  "Фарход" < "Шахром",
  "яблоко" < "арбуз",
  "Dushanbe" < "dushanbe",
  "100" < "20",
  100 < 20,
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const balance = 120;
const price = 35;
const count = 3;

// console.log("Хватает:", ...);
// console.log("Остаток:", ...);

Хватает: true
Остаток: 15

02 Строгое и нестрогое равенство

В JavaScript два вида «равно». Они выглядят похоже, но ведут себя совершенно по-разному.

• === — строгое равенство. Сравнивает и значение, и тип. Если типы разные — сразу false, без попыток что-то преобразовать.
• == — нестрогое равенство. Если типы разные, сначала пытается привести значения к общему типу, и только потом сравнивает.

console.log(5 === 5);     // → true: число и число
console.log(5 === "5");   // → false: число и строка, типы разные
console.log(5 == "5");    // → true: == превратило строку "5" в число и сравнило

Таблица: что происходит с ==

Нестрогое сравнение подчиняется длинному списку правил. Запоминать их все не нужно, но полезно один раз увидеть, к чему они приводят:

console.log(0 == false);          // true
console.log("" == 0);             // true
console.log("0" == false);        // true
console.log("2" == true);         // false
console.log(null == undefined);   // true
console.log(null == 0);           // false
console.log(null >= 0);          // true
console.log(NaN == NaN);          // false

const answer = "";
if (answer == 0) {
  console.log("Ответ — ноль!");  // выведется, хотя пользователь ничего не ввёл
}

const answer = "";
if (answer !== "" && Number(answer) === 0) {
  console.log("Ответ — ноль!");  // не выведется
}

Читать подробнее: learn.javascript.ru: Сравнение разных типов, строгое сравнение · MDN: Сравнение и равенство

// Впишите прогноз: true или false для каждого сравнения (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", "", ""];
const actual = [
  5 == "5",
  5 === "5",
  0 == false,
  null == undefined,
  null === undefined,
  NaN == NaN,
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const pin = "1234";
const entered = 1234;

if (pin === entered) {
  console.log("Доступ разрешён");
} else {
  console.log("Доступ запрещён");
}

Доступ разрешён

// Впишите прогноз: true или false для каждого выражения (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", "", "", "", ""];
const actual = [
  "" == 0,
  "0" == false,
  null == 0,
  null >= 0,
  undefined == null,
  undefined == 0,
  "1" == 1.0,
  "abc" == NaN,
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

03 Истинные и ложные значения (truthy / falsy)

Условие не обязано быть сравнением. В if можно положить любое значение, и JavaScript сам превратит его в true или false. Это то самое неявное приведение к boolean, о котором шла речь в уроке про типы.

Всего восемь «ложных» значений, остальное — истина

Значения, которые превращаются в false, называют falsy («ложноватые»). Запомните основные пять — они встречаются каждый день:

Всё остальное — truthy («истинное»): любое ненулевое число (включая отрицательные), любая непустая строка, включая "0" и "false". Проверить любое значение можно через Boolean(...) или двойное отрицание !!:

console.log(Boolean(0));         // → false
console.log(Boolean(""));        // → false
console.log(Boolean(null));      // → false
console.log(Boolean(NaN));       // → false

console.log(Boolean(1));         // → true
console.log(Boolean(-5));        // → true: отрицательное число — тоже истина
console.log(Boolean("Мадина"));  // → true
console.log(Boolean(" "));       // → true: пробел — это символ, строка не пустая!
console.log(Boolean("0"));       // → true: строка "0" не пустая
console.log(Boolean("false"));   // → true: строка с текстом false — просто текст

Как это используется

Самая частая причина смотреть на truthy/falsy — проверка «задал ли пользователь значение вообще»:

const username = "";   // пользователь ничего не ввёл

if (username) {
  console.log("Добро пожаловать, " + username);
} else {
  console.log("Введите имя");
}

const discount = 0;   // скидка 0% — это нормальное значение

if (discount) {
  console.log("Скидка:", discount + "%");
} else {
  console.log("Скидки нет");   // ✖ ошибка логики: 0% тоже скидка
}

// правильно: спрашиваем именно «задано ли значение»
if (discount !== undefined) {
  console.log("Скидка:", discount + "%");
}

Читать подробнее: MDN: Falsy · MDN: Truthy · learn.javascript.ru: Логические операторы

// Впишите прогноз: true или false для каждого значения (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", "", "", "", ""];
const actual = [
  Boolean(0),
  Boolean("0"),
  Boolean(""),
  Boolean(" "),
  Boolean(null),
  Boolean("false"),
  Boolean(-1),
  Boolean(undefined),
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const name1 = "Мадина";
const name2 = "";
let name3;   // значение не задано

// для каждой переменной своя конструкция if / else

Привет, Мадина!
Привет, гость!
Привет, гость!

const discount = 0;

if (discount) {
  console.log("Скидка: " + discount + "%");
} else {
  console.log("Скидки нет");
}

Скидка: 0%

04 Логические операторы: &&, ||, !

Одного вопроса часто мало. «Можно в клуб, если вам 18 или больше и у вас есть паспорт». Чтобы объединять вопросы, используют три логических оператора:

&& — «и»

Истина, только если оба условия истинны.

|| — «или»

Истина, если хотя бы одно из условий истинно.

! — «не»

Переворачивает значение: !true — это false, и наоборот.

const age = 20;
const hasTicket = true;

console.log(age >= 18 && hasTicket);   // → true: оба условия выполнены
console.log(age < 18 || hasTicket);    // → true: достаточно билета
console.log(!hasTicket);               // → false
console.log(age >= 18 && !hasTicket);  // → false

Приоритет и скобки

Порядок выполнения такой же, как в математике: сначала !, затем &&, потом ||. Как умножение идёт раньше сложения, так «и» идёт раньше «или». Чтобы не гадать и не путать читателя, в сложных условиях ставьте скобки.

const isStudent = true;
const hasCard = false;
const isWeekend = false;

// без скобок: сначала &&, потом ||
console.log(isStudent || hasCard && isWeekend);     // → true
// со скобками: порядок меняется
console.log((isStudent || hasCard) && isWeekend);   // → false

Закон «не» (законы де Моргана)

Условие «не (А или Б)» означает то же самое, что «не А и не Б». И наоборот: «не (А и Б)» — это «не А или не Б». Это помогает упрощать запутанные условия.

const isClosed = false;
const isFull = true;

// «Можно войти, если НЕ (закрыто ИЛИ мест нет)»
console.log(!(isClosed || isFull));     // → false
// то же самое: «НЕ закрыто И НЕ заполнено»
console.log(!isClosed && !isFull);     // → false

Короткое замыкание и возвращаемые значения

Здесь начинается самое интересное. Операторы && и || на самом деле возвращают не true / false, а одно из значений, которые сравнивают. И делают это «лениво», слева направо, останавливаясь как только ответ понятен. Это называется короткое замыкание.

• a || b — берёт первое истинное значение. Если истинных нет — вернёт последнее.
• a && b — берёт первое ложное значение. Если ложных нет — вернёт последнее.

console.log(0 || 10);                  // → 10: 0 ложь, идём дальше
console.log("Алиша" || "гость");       // → Алиша: первое значение уже истинное, дальше не смотрим
console.log(null || undefined || "запасной"); // → запасной

console.log(1 && 2 && 3);                // → 3: все истинны, вернули последнее
console.log(1 && 0 && 3);                // → 0: остановились на первом ложном
console.log(null && "не дойдём");        // → null

Этим пользуются на практике. Значение по умолчанию:

const nickname = "";                          // пользователь ничего не ввёл
const shown = nickname || "Гость";            // если пусто — подставляем «Гость»
console.log("Привет,", shown);                // → Привет, Гость

И безопасное «сделай только если»: правая часть && вычисляется лишь тогда, когда левая истинна.

const isAdmin = true;
isAdmin && console.log("Открываем панель администратора");  // выполнится
const isGuest = false;
isGuest && console.log("Это сообщение не появится");        // правая часть даже не вычислялась

Оператор ?? — «если пусто» только для null и undefined

У || есть недостаток, который вы уже видели: он считает ложью 0 и пустую строку. Для значений по умолчанию это часто неудобно: громкость 0 — это честная настройка, а не «значение не задано». Оператор ?? («нулевое слияние») подставляет запасное значение только если слева null или undefined.

const volume = 0;                 // пользователь выключил звук

console.log(volume || 50);        // → 50 ✖ выключенный звук включился сам
console.log(volume ?? 50);        // → 0  ✔ ноль сохранён

let theme;                        // настройка не задана (undefined)
console.log(theme ?? "светлая");  // → светлая

Правило выбора простое: нужна замена для «пусто» вообще (в том числе 0 и "") — берём ||; нужна замена только для «не задано» — берём ??.

Читать подробнее: learn.javascript.ru: Логические операторы · MDN: Оператор нулевого слияния ??

const age = 16;
const hasTicket = true;

// три строки console.log

false
true
false

// Впишите прогноз: результат каждого выражения по порядку (каждое значение — текстом, как его покажет консоль)
const prediction = ["", "", "", "", "", "", "", ""];
const actual = [
  0 || 10,
  0 ?? 10,
  "Алиша" || "гость",
  null && "текст",
  1 && 2 && 3,
  1 && 0 && 3,
  null || undefined || "последний",
  null ?? "пусто",
].map(String);
console.log(actual.join("|") === prediction.join("|") ? "Верно!" : "Не угадали, подумайте ещё");

Верно!

const ageA = 70;
const studentA = false;
const ageB = 16;
const studentB = true;

// две строки с шаблонными строками и логическими выражениями

А: бесплатно: true, скидка: false
Б: бесплатно: false, скидка: true

const volume = 0;
const nickname = "";
let theme;

// console.log("Громкость:", ...);
// console.log("Ник:", ...);
// console.log("Тема:", ...);

Громкость: 0
Ник: Гость
Тема: светлая

05 Условный оператор if / else if / else

Теперь, когда мы умеем задавать вопросы, научим программу выбирать путь. Для этого служит оператор if («если»).

const temperature = 35;

if (temperature > 30) {
  console.log("Жарко, берите воду");
}
console.log("Программа продолжается");

Код в фигурных скобках выполняется, только если условие в круглых скобках истинно. Если ложно — блок просто пропускается, и программа идёт дальше.

else — «в остальных случаях»

const balance = 8;
const fare = 3;   // проезд в маршрутке

if (balance >= fare) {
  console.log("Проезд оплачен");
} else {
  console.log("Недостаточно средств");
}

else if — несколько вариантов

Если вариантов больше двух, между if и else добавляют сколько угодно else if. Условия проверяются сверху вниз, до первого истинного; остальные уже не проверяются.

const score = 72;

if (score >= 86) {
  console.log("Оценка: 5");
} else if (score >= 71) {
  console.log("Оценка: 4");
} else if (score >= 56) {
  console.log("Оценка: 3");
} else {
  console.log("Оценка: 2");
}

const score = 90;

if (score >= 56) {
  console.log("Оценка: 3");     // сработает уже здесь
} else if (score >= 71) {
  console.log("Оценка: 4");     // никогда не дойдём
} else if (score >= 86) {
  console.log("Оценка: 5");     // и сюда тоже
}

Составные условия и вложенность

Внутри условия можно использовать &&, || и !. А внутрь блока — класть другие if. Но много уровней вложенности трудно читать: чаще проще объединить условия через &&.

const hour = 14;
const isWorkDay = true;

if (isWorkDay && hour >= 9 && hour < 18) {
  console.log("Офис открыт");
} else {
  console.log("Офис закрыт");
}

Читать подробнее: learn.javascript.ru: Условное ветвление · MDN: if...else

const color = "yellow";

// цепочка if / else if / else

Приготовьтесь

const n = 17;

// if (...) { ... } else { ... }

17 — нечётное

const total = 480;
let discount = 0;

// определите discount через if / else if

// console.log("Скидка: " + discount + "%");
// console.log("К оплате: " + ...);

Скидка: 10%
К оплате: 432

const score = 90;

if (score >= 56) {
  console.log("Оценка: 3");
} else if (score >= 71) {
  console.log("Оценка: 4");
} else if (score >= 86) {
  console.log("Оценка: 5");
} else {
  console.log("Оценка: 2");
}

Оценка: 5

const a = 5;
const b = 5;
const c = 8;

// вложенный if: существует ли, затем тип

Треугольник существует
Равнобедренный

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

Когда нужно просто выбрать одно из двух значений, конструкция if / else занимает слишком много места. Для таких случаев есть сокращённая запись — тернарный оператор. Он единственный в JavaScript с тремя частями («тернарный» значит «тройной»).

const age = 20;

// длинная запись
let status1;
if (age >= 18) {
  status1 = "взрослый";
} else {
  status1 = "ребёнок";
}

// короткая запись: условие ? значение_если_да : значение_если_нет
const status2 = age >= 18 ? "взрослый" : "ребёнок";

console.log(status1);   // → взрослый
console.log(status2);   // → взрослый

Где он удобен

Результат тернарного оператора — значение, поэтому его можно вставить прямо в шаблонную строку или в аргумент console.log:

const items = 0;
console.log(`В корзине: ${items === 0 ? "пусто" : items + " шт."}`);

const hour = 7;
console.log("Чойхона:", hour >= 9 && hour < 22 ? "открыта" : "закрыта");

Цепочка тернарных операторов

Тернарные операторы можно соединять, это заменяет else if. Работает, но уже с двумя уровнями читать трудно.

const temp = 22;
const feel = temp >= 30 ? "жарко"
           : temp >= 15 ? "тепло"
           : "прохладно";
console.log(feel);   // → тепло

const x = a ? b ? 1 : 2 : c ? 3 : d ? 4 : 5;

let label;
if (temp >= 30) {
  label = "жарко";
} else if (temp >= 15) {
  label = "тепло";
} else {
  label = "прохладно";
}

Читать подробнее: learn.javascript.ru: Условный оператор «?» · MDN: Условный (тернарный) оператор

const age = 20;
let status;
if (age >= 18) {
  status = "Совершеннолетний";
} else {
  status = "Несовершеннолетний";
}
console.log(status);

const age = 20;
// ваш тернарный оператор: объявите status и положите в него результат
console.log(status);

Совершеннолетний

const hour1 = 7;
const hour2 = 14;

// две строки: console.log("Чойхона:", ...)

Чойхона: закрыта
Чойхона: открыта

const t1 = 31;
const t2 = 20;
const t3 = 5;

// const d1 = ...
// const d2 = ...
// const d3 = ...

console.log(d1);
console.log(d2);
console.log(d3);

Жарко
Тепло
Прохладно

07 Конструкция switch

Если нужно сравнить одну и ту же переменную со многими конкретными значениями, цепочка из десяти else if получается громоздкой. Для этого придумали switch («переключатель»).

const day = 3;

switch (day) {
  case 1:
    console.log("Понедельник");
    break;
  case 2:
    console.log("Вторник");
    break;
  case 3:
    console.log("Среда");
    break;
  default:
    console.log("Другой день");
}

1. Вычисляется выражение в скобках после switch — здесь day.
2. Значение сравнивается строго (как ===) с каждым case сверху вниз.
3. Находится первое совпадение — и код выполняется с этого места вниз.
4. break выходит из switch. Если break нет — выполнение продолжается дальше.
5. default — «ничего не подошло», аналог else. Его пишут в конце.

Забыли break: «проваливание» (fall-through)

Самая известная ловушка switch. Без break JavaScript находит нужный case и выполняет всё, что ниже, пока не встретит break или конец switch.

const n = 2;

switch (n) {
  case 1:
    console.log("Один");
  case 2:
    console.log("Два");
  case 3:
    console.log("Три");
  default:
    console.log("Неизвестно");
}
// выведет: Два, Три, Неизвестно — всё, что ниже совпавшего case

Полезное проваливание: несколько case — одно действие

Бывает и полезная сторона. Если у нескольких значений действие одинаковое, их можно записать подряд, а break поставить только после общего кода:

const month = 4;

switch (month) {
  case 12:
  case 1:
  case 2:
    console.log("Зима");
    break;
  case 3:
  case 4:
  case 5:
    console.log("Весна");
    break;
  case 6:
  case 7:
  case 8:
    console.log("Лето");
    break;
  case 9:
  case 10:
  case 11:
    console.log("Осень");
    break;
  default:
    console.log("Такого месяца нет");
}

Сравнение строгое

switch сравнивает значения как ===, без приведения типов. Поэтому число 1 и строка "1" — разные значения:

const choice = "1";   // строка, как из поля формы

switch (choice) {
  case 1:
    console.log("Число один");
    break;
  case "1":
    console.log("Строка «1»");
    break;
  default:
    console.log("Не нашли");
}

Читать подробнее: learn.javascript.ru: Конструкция switch · MDN: switch

const day = 5;

// switch (day) { ... }

Пятница

const day = 6;

// switch (day) { ... }

Выходной

const bread = "tandir";

switch (bread) {
  case "lavash":
    console.log("Лаваш — тонкий");
  case "tandir":
    console.log("Тандыр — круглая лепёшка");
  case "non":
    console.log("Нон — домашний");
  default:
    console.log("Неизвестный хлеб");
}

Тандыр — круглая лепёшка

const city = "Бохтар";

// switch (city) { ... }

Доставка: 2 дня

08 ИИ-блок: GitHub Copilot в VS Code

Напомним правила курса: сначала пробуйте сами 15 минут, не вставляйте код, который не можете объяснить построчно, и всегда проверяйте крайние случаи руками. Copilot включаем на практике и выключаем на контрольных заданиях.

1. Как Copilot работает в редакторе

Пока вы печатаете, Copilot показывает бледный «призрачный» текст — предложение продолжить. Его можно принять целиком, по словам или отклонить. Клавиши в стандартной раскладке VS Code:

В inline chat вы выделяете кусок кода, нажимаете Ctrl/Cmd + I и пишете запрос обычными словами. Есть и короткие команды: /explain — объяснить код, /fix — найти ошибку, /tests — предложить тесты. Для новичка самое ценное — именно /explain и вопрос «какие крайние случаи я не учёл?».

2. Где Copilot помогает

• Рутина: повторяющиеся строки, скобки, шаблонный код. Руки не устают, голова свободна для логики.
• Забытый синтаксис: «как записать switch?» — быстрее, чем искать в документации.
• Объяснение чужого кода: выделили непонятное, нажали /explain.
• Данные для проверки: «предложи 10 тестовых значений для проверки возраста».
• Второй взгляд: «найди граничные случаи в моём условии» после того, как вы написали код сами.

3. Где Copilot мешает учиться

Условия и логика — именно та тема, где мышление важнее печатания. Мозг учится, когда напрягается: вы сами решаете, какой оператор и в каком порядке. Если вы просто нажимаете Tab, у вас появляется иллюзия понимания: код есть, а в голове пусто. На контрольной и на собеседовании вы останетесь один.

4. Дисциплина «Copilot off»

Привычка работы, которой мы придерживаемся на курсе:

1. Прочитайте задачу и напишите решение словами или схемой в тетради: какие бывают случаи, в каком порядке их проверять.
2. Выключите Copilot и напишите код сами. Нажмите на значок Copilot в нижней строке состояния VS Code и выберите «Disable Completions» (отключить подсказки) — для всех файлов или только для JavaScript.
3. Запустите и проверьте на граничных значениях и на «плохих» данных.
4. Только потом включите Copilot как рецензента: выделите код, Ctrl/Cmd + I, «найди граничные случаи, которые я не учёл».
5. Сравните с вашим решением. Что он предложил такого, чего вы не знали? Запишите в конспект одну строку.

5. Промпты для сегодняшнего урока

Помните формулу: контекст → задача → ограничения → формат ответа → проверка.

Теперь два упражнения: Copilot-подобные «предложения», которые выглядят правдоподобно, но ошибаются. Ваша работа — поймать ошибку, как рецензент.

const age = 12;

// предложение Copilot:
if (age < 12) {
  console.log("Бесплатно");
} else {
  console.log("Платно");
}

Бесплатно

const balance = 0;

// предложение Copilot:
if (balance) {
  console.log("Баланс: " + balance + " сомони");
} else {
  console.log("Баланс неизвестен");
}

Баланс: 0 сомони

09 Практика на уроке: консольный калькулятор

Соберём первую настоящую программу. Это калькулятор: он берёт два числа и знак действия, считает и выводит ответ в консоль. Интерактивного ввода (через prompt) на этой странице нет, поэтому данные мы задаём переменными вверху: a, b и operation. Меняйте их и запускайте — так вы и тестируете программу.

Каркас калькулятора

1. Данные: два числа a, b и строка operation со знаком.
2. Выбор действия: switch (operation) с вариантами "+", "-", "*", "/".
3. Результат: вывести строку вида 12 * 4 = 48.
4. Защита: деление на ноль — отдельная ошибка; неизвестная операция — ветка default.

const a = 12;
const b = 4;
const operation = "+";

switch (operation) {
  case "+":
    console.log(`${a} + ${b} = ${a + b}`);
    break;
  case "-":
    console.log(`${a} - ${b} = ${a - b}`);
    break;
  // здесь будут "*" и "/"
  default:
    console.log("Неизвестная операция");
}

const a = 12;
const b = 4;
const operation = "*";

// switch (operation) { ... }

12 * 4 = 48

const a = 10;
const b = 0;
const operation = "/";

// switch (operation) { ... }

Ошибка: на ноль делить нельзя

const p1 = 9;
const p2 = 6;
const p3 = 7;

// if / else if / else и &&

Минимум: 6

const n = 15;

// if / else if / else

FizzBuzz

★ Домашнее задание: три консольные программы

Три программы, каждая в своём файле. Запускать их можно в консоли браузера (DevTools из первого урока) или на этой странице. Данные задавайте переменными в начале файла. Без функций и циклов: только переменные, if / else, тернарный оператор и switch.

Программа 1. Калькулятор

Развитие классной работы: a, b, operation.

• ☐ Операции +, -, *, /, %, ** через switch.
• ☐ Деление и остаток на ноль — сообщение об ошибке вместо результата.
• ☐ Неизвестная операция — сообщение об ошибке (default).
• ☐ Проверка типов: если a или b не число (typeof a !== "number"), вывести Ошибка: нужны числа и не считать.
• ☐ Вывод в виде 12 * 4 = 48.

Программа 2. Определитель високосного года

Год задан переменной year. Правило: год високосный, если он делится на 4, но не делится на 100, за исключением годов, которые делятся на 400.

• ☐ Вывод: 2024 — високосный год или 2023 — не високосный год.
• ☐ Условие записано одним составным выражением с && и || и скобками, либо цепочкой if / else if — выберите и объясните выбор.
• ☐ В комментарии в начале файла — таблица проверенных годов (минимум пять, все из таблицы выше).
• ☐ Эту программу пишите с выключенным Copilot. Включите его только в конце, для проверки граничных случаев.

Программа 3. Конвертер валют

Курсы зафиксированы в программе: 1 USD = 10.5 сомони, 1 RUB = 0.12 сомони. Заданы сумма amount, исходная валюта from и целевая to (строки "TJS", "USD", "RUB"). Идея: сначала переведите сумму в сомони («общий знаменатель»), потом из сомони в нужную валюту.

const amount = 100;
const from = "USD";
const to = "TJS";

const USD_RATE = 10.5;   // сколько сомони стоит 1 доллар
const RUB_RATE = 0.12;   // сколько сомони стоит 1 рубль

let inSomoni;

switch (from) {
  case "TJS":
    inSomoni = amount;
    break;
  case "USD":
    inSomoni = amount * USD_RATE;
    break;
  // здесь будет "RUB"
  default:
    console.log("Неизвестная исходная валюта");
}

console.log(inSomoni);   // → 1050
// дальше: второй switch (to) считает итог из inSomoni

• ☐ Все пары из трёх валют работают, включая USD ↔ RUB через сомони.
• ☐ Если from === to — вывести сумму без пересчёта.
• ☐ Неизвестная валюта (в любом поле) или отрицательная сумма — сообщение об ошибке.
• ☐ Результат округляется до 2 знаков: Math.round(x * 100) / 100.
• ☐ Бонус: добавьте четвёртую валюту (например, EUR) и покажите, сколько мест в коде пришлось изменить.

Что сдать

1. Три файла: calculator.js, leap-year.js, converter.js в папке lesson-03 репозитория GitHub (или архив в Telegram-группу).
2. В начале каждого файла — комментарий с тестовыми значениями: какие входные данные вы проверили и что получилось.
3. Файл README.md из трёх строк: в каких задачах вы использовали Copilot; что он предложил; что вы исправили или отклонили.
4. Будьте готовы на проверке объяснить любую строку: преподаватель может попросить.

Как оцениваем (0–10)