⚡ JavaScript

Condiciones (if/else/switch) en JavaScript (Node.js): guía detallada

Lección 7 / 35 • Teoría de lectura completa

Переменная — это основа любой программы. Без переменных программирование было бы невозможным: мы бы не могли ни сохранить данные, ни передать их, ни изменить. В этом уроке вы узнаете, что такое переменные в JavaScript, почему существуют целых три способа их создать (var, let, const), и какие типы данных есть в языке.

Что такое переменная? Аналогия с коробкой

Представьте, что у вас есть стеллаж с коробками. На каждой коробке написано имя (этикетка), а внутри лежит что-то конкретное. Например, коробка "имя" — внутри листок с текстом "Дима". Коробка "возраст" — внутри листок с числом "15". Коробка "любимый_цвет" — внутри "синий".

Переменная в программировании — это exactly такая коробка в памяти компьютера. У неё есть:

Имя (идентификатор) — как этикетка на коробке, по которой мы её находим
Значение — то, что лежит внутри
Тип — какой вид данных хранится (текст, число, и т.д.)

Зачем нужны переменные? Чтобы запомнить данные и потом использовать их снова. Ввёл пользователь своё имя — сохранили в переменную. Нужно поздороваться — взяли из переменной. Изменил имя — обновили коробку.

Создание переменной: let

Самый современный и правильный способ создать переменную — ключевое слово let. Думайте о нём как о слове "пусть будет" или "создай коробку с именем..."

// Создаём переменную и сразу кладём в неё значение
let имя = "Дима";
let возраст = 15;
let любимыйЦвет = "синий";

// Выводим переменные
console.log(имя);         // Дима
console.log(возраст);     // 15
console.log(любимыйЦвет); // синий

Разбираем первую строку: let — ключевое слово, объявляем переменную. имя — придуманное нами название переменной. = — оператор присваивания (это не "равно" как в математике, это "положить в коробку"). "Дима" — значение, которое кладём в переменную. ; — точка с запятой в конце инструкции.

Самое важное: = в программировании — это не проверка равенства, а присваивание. Читается как "пусть переменная имя равняется строке Дима" или "положи строку Дима в коробку с именем имя".

Изменение значения переменной

В этом и суть "переменной" — значение можно менять (переменное значение):

let счёт = 0;
console.log(счёт); // 0

счёт = 1;          // Меняем значение (let писать уже не нужно!)
console.log(счёт); // 1

счёт = счёт + 1;   // Берём текущее значение и прибавляем 1
console.log(счёт); // 2

// Можно написать короче:
счёт += 1;         // То же самое что счёт = счёт + 1
счёт++;            // Ещё короче — увеличить на 1
console.log(счёт); // 4

Важно: let пишем только один раз — при создании переменной. Когда просто меняем значение — пишем только имя переменной и новое значение.

Константа: const

Аналогия: если let — это временный стикер, который можно переклеить, то const — это надпись, выгравированная на металле. Изменить нельзя.

const PI = 3.14159;
const НАЗВАНИЕ_САЙТА = "МойСайт";
const ДАТА_РОЖДЕНИЯ = "2010-05-15";

console.log(PI);             // 3.14159
console.log(НАЗВАНИЕ_САЙТА); // МойСайт

// Попытка изменить const вызовет ошибку:
// PI = 3;  // TypeError: Assignment to constant variable.
// Браузер скажет: "Нельзя! Это константа!"

const используется для значений, которые не должны меняться: математические константы (π, скорость света), конфигурация, ключи API. Это защита от случайных изменений — если вы случайно попытаетесь изменить константу, JavaScript немедленно сообщит об ошибке.

Хорошая практика: имена констант пишут ЗАГЛАВНЫМИ_БУКВАМИ_ЧЕРЕЗ_ПОДЧЁРКИВАНИЕ — так сразу видно, что это константа.

Старый способ: var

До 2015 года в JavaScript был только один способ создать переменную — var. Его до сих пор можно встретить в старом коде, поэтому нужно знать.

var старая_переменная = "Я создана через var";
console.log(старая_переменная); // Я создана через var

var старая_переменная = "Можно объявить снова!"; // Не ошибка для var
console.log(старая_переменная); // Можно объявить снова!

var имеет несколько проблемных особенностей, которые приводили к трудно находимым ошибкам:

Зачем придумали let и const?

Особенность	var	let	const
Повторное объявление	✅ Можно (опасно!)	❌ Ошибка	❌ Ошибка
Изменение значения	✅ Можно	✅ Можно	❌ Нельзя
Область видимости	Функция	Блок	Блок
Hoisting (подъём)	Да (undefined)	Да (ошибка)	Да (ошибка)
Рекомендация	❌ Избегать	✅ Использовать	✅ Использовать

Правило для новичка: используйте const по умолчанию. Если значение будет меняться — используйте let. Про var забудьте до тех пор, пока не встретите в чужом коде.

Правила именования переменных

Имя переменной — как имя человека: оно должно быть уникальным и желательно говорящим.

// Правильные имена:
let имяПользователя = "Аня";     // camelCase — рекомендуемый стиль
let количество_товаров = 5;       // snake_case — тоже работает
let _приватная = "скрытая";      // Можно начинать с _
let $цена = 1000;                 // Можно начинать с $

// Неправильные имена:
// let 2наименование = "плохо";  // Нельзя начинать с цифры
// let моя переменная = 5;       // Нельзя пробелы
// let let = "нет";              // Нельзя использовать ключевые слова

// Говорящие имена — хорошо:
let возрастПользователя = 18;
let суммаЗаказа = 1500;
let естьЛиСкидка = true;

// Непонятные имена — плохо:
let a = 18;     // Что это за 'a'?
let x2 = 1500;  // И это?
let fl = true;  // А это вообще что?

Стандарт в JavaScript — camelCase (верблюжийРегистр): первое слово с маленькой буквы, каждое следующее слово начинается с большой. Это не правило языка, а соглашение сообщества — код читают другие люди, и им важно понимать что происходит.

Типы данных в JavaScript

JavaScript — язык с динамической типизацией. Это значит, что вам не нужно заранее указывать, что именно лежит в переменной — число, текст или что-то ещё. JavaScript сам разберётся.

Основных типов данных семь:

1. Number (Число)

let целоеЧисло = 42;
let дробноеЧисло = 3.14;
let отрицательное = -100;
let большое = 1_000_000; // Нижнее подчёркивание для читаемости

// Специальные числовые значения:
let бесконечность = Infinity;    // Результат деления на ноль
let минусБесконечность = -Infinity;
let неЧисло = NaN;               // Not a Number — возникает при ошибочных вычислениях

console.log(10 / 0);      // Infinity
console.log("abc" * 2);   // NaN (нельзя умножить текст на число)
console.log(NaN === NaN); // false (NaN не равен даже самому себе!)

// Математические операции:
console.log(10 + 3);   // 13 (сложение)
console.log(10 - 3);   // 7  (вычитание)
console.log(10 * 3);   // 30 (умножение)
console.log(10 / 3);   // 3.3333... (деление)
console.log(10 % 3);   // 1  (остаток от деления — очень полезно!)
console.log(10 ** 3);  // 1000 (возведение в степень)

2. String (Строка — текст)

let одинарные = 'Одинарные кавычки';
let двойные = "Двойные кавычки";
let обратные = `Обратные кавычки (шаблонные строки)`;

// Объединение строк (конкатенация):
let имя = "Петя";
let приветствие = "Привет, " + имя + "!";
console.log(приветствие); // Привет, Петя!

// Длина строки:
console.log("Привет".length); // 6

// Строки — неизменяемы:
let слово = "Мир";
// slovo[0] = "p"; // Не сработает! Строки нельзя изменять посимвольно
console.log(слово[0]); // М — но только для чтения

3. Boolean (Булево значение)

// Только два возможных значения:
let истина = true;
let ложь = false;

// Часто используется в условиях:
let пользовательВошёл = true;
let корзинаПуста = false;

// Результат сравнений — тоже boolean:
console.log(5 > 3);    // true
console.log(5 < 3);    // false
console.log(5 === 5);  // true (строгое равенство)
console.log(5 !== 3);  // true (строгое неравенство)

4. Null (Ничего / намеренное отсутствие)

// null — это намеренная "пустота". Программист специально говорит "здесь ничего нет"
let профиль = null;   // Профиль ещё не загружен
let ответ = null;     // Ответ ещё не получен

// После загрузки:
профиль = { имя: "Аня", возраст: 20 };

console.log(профиль); // { имя: 'Аня', возраст: 20 }

5. Undefined (Не определено)

// undefined появляется само — когда переменная объявлена, но не инициализирована
let x;
console.log(x); // undefined (мы создали коробку, но ничего в неё не положили)

// Разница между null и undefined:
let намеренноПусто = null;       // Программист сказал "здесь ничего"
let ещёНеПолучено;               // Просто не присвоили значение
console.log(намеренноПусто);    // null
console.log(ещёНеПолучено);     // undefined

6. Object (Объект)

// Объект — это набор связанных данных
let пользователь = {
  имя: "Дима",
  возраст: 16,
  городРожден: "Москва"
};
console.log(пользователь.имя); // Дима
// Подробнее об объектах — в уроке 5

7. Symbol и BigInt (продвинутые)

// BigInt — для очень больших чисел (больше 2^53)
let огромноеЧисло = 9007199254740992n; // n в конце = BigInt

// Symbol — уникальные идентификаторы (продвинутая тема)
let уникальныйКлюч = Symbol("описание");

Оператор typeof

Хотите узнать, какого типа данные в переменной? Используйте typeof:

console.log(typeof 42);          // "number"
console.log(typeof "Привет");    // "string"
console.log(typeof true);        // "boolean"
console.log(typeof undefined);   // "undefined"
console.log(typeof null);        // "object" — это баг в JS, null не объект!
console.log(typeof {});          // "object"
console.log(typeof []);          // "object" (массивы тоже объекты)
console.log(typeof function(){}); // "function"

let загадка;
console.log(typeof загадка); // "undefined" — переменная без значения

Историческая заметка: typeof null === "object" — это известная ошибка в JavaScript, которая появилась ещё в 1995 году и не исправлена по сей день из соображений обратной совместимости. Миллионы сайтов зависят от этого поведения, поэтому его не трогают.

Шаблонные строки (Template Literals)

До ES2015 для вставки переменных в строки использовали конкатенацию с +. Это неудобно и трудночитаемо. Шаблонные строки решают эту проблему элегантно.

let имя = "Маша";
let возраст = 14;
let город = "Санкт-Петербург";

// Старый способ — через +:
let старый = "Привет! Меня зовут " + имя + ", мне " + возраст + " лет, я из " + город + ".";

// Новый способ — шаблонные строки (обратные кавычки!):
let новый = `Привет! Меня зовут ${имя}, мне ${возраст} лет, я из ${город}.`;

console.log(старый); // Привет! Меня зовут Маша, мне 14 лет, я из Санкт-Петербург.
console.log(новый);  // Привет! Меня зовут Маша, мне 14 лет, я из Санкт-Петербург.

// Внутри ${} можно писать любые выражения:
let a = 5;
let b = 3;
console.log(`${a} + ${b} = ${a + b}`);           // 5 + 3 = 8
console.log(`${a} в квадрате = ${a ** 2}`);       // 5 в квадрате = 25
console.log(`Сейчас ${new Date().getFullYear()} год`); // Сейчас 2025 год

// Многострочные строки (с `` можно делать переносы):
let текст = `Первая строка.
Вторая строка.
Третья строка.`;
console.log(текст);

Синтаксис ${выражение} называется интерполяцией. Внутри фигурных скобок можно вставить не только переменную, но и любое выражение JavaScript — вызов функции, математику, условие.

Преобразование типов

JavaScript умеет автоматически преобразовывать типы данных (неявное преобразование), но это часто приводит к неожиданным результатам. Лучше делать это явно.

// Неявное преобразование (JavaScript делает сам, часто неожиданно):
console.log("5" + 3);    // "53" (число стало строкой, произошла конкатенация!)
console.log("5" - 3);    // 2   (строка стала числом, произошло вычитание)
console.log("5" * "3");  // 15  (обе строки стали числами)
console.log(true + 1);   // 2   (true = 1)
console.log(false + 1);  // 1   (false = 0)
console.log("" == false); // true (оба "пустые")
console.log(null == undefined); // true (оба "ничего")

// Явное преобразование (программист делает сам, предсказуемо):
// Строка → Число:
let строка = "42";
let число = Number(строка);     // 42
let тожеЧисло = parseInt("42px"); // 42 (извлечь число из начала строки)
let дробь = parseFloat("3.14rem"); // 3.14

// Число → Строка:
let n = 100;
let s = String(n);    // "100"
let s2 = n.toString(); // "100"
let s3 = `${n}`;      // "100" (через шаблонную строку)

// Что угодно → Boolean:
console.log(Boolean(0));          // false
console.log(Boolean(""));         // false (пустая строка)
console.log(Boolean(null));       // false
console.log(Boolean(undefined));  // false
console.log(Boolean(NaN));        // false
// Всё остальное — true:
console.log(Boolean(1));          // true
console.log(Boolean("привет"));   // true
console.log(Boolean([]));         // true (даже пустой массив!)
console.log(Boolean({}));         // true (даже пустой объект!)

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

В JavaScript есть два вида проверки равенства, и это путает всех новичков:

// == (нестрогое равенство) — сравнивает значения, игнорируя тип:
console.log(5 == "5");   // true  (число 5 и строка "5" считаются равными)
console.log(0 == false); // true  (ноль считается false)
console.log(null == undefined); // true

// === (строгое равенство) — сравнивает значение И тип:
console.log(5 === "5");   // false (разные типы!)
console.log(0 === false); // false (разные типы!)
console.log(null === undefined); // false (разные типы!)
console.log(5 === 5);    // true  (одинаковые значение и тип)

// Рекомендация: ВСЕГДА используйте === вместо ==
// Это избавит вас от множества неожиданных ошибок

Практический пример: калькулятор возраста

// Пользователь вводит год рождения, мы считаем возраст
const ТЕКУЩИЙ_ГОД = 2025; // const, потому что не изменится

let ввод = prompt("В каком году ты родился?");
let годРождения = Number(ввод); // Явное преобразование строки в число

// Проверяем, что ввели правильное число
if (isNaN(годРождения)) {
  alert("Это не число!");
} else {
  let возраст = ТЕКУЩИЙ_ГОД - годРождения;
  let сообщение = `Тебе ${возраст} лет (или ${возраст - 1}, если день рождения ещё не был)`;
  alert(сообщение);
  console.log(`Год рождения: ${годРождения}, Текущий год: ${ТЕКУЩИЙ_ГОД}, Возраст: ${возраст}`);
}

Здесь используется всё, что мы изучили: const для постоянного значения, let для меняющихся, явное преобразование типа, шаблонные строки, проверка isNaN().

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

Использование переменной до объявления. let нельзя использовать до того, как она объявлена — получите ошибку ReferenceError.
Забыть про тип данных при сложении. "5" + 3 = "53", а не 8. Если данные приходят от пользователя (prompt, input) — они всегда строки! Не забудьте преобразовать.
Использовать = вместо === для сравнения. if (x = 5) — это не проверка, это присваивание! Правильно: if (x === 5).
Изменять const. Если данные будут меняться — используйте let, не const.
Неговорящие имена переменных. let a = 18 vs let возрастПользователя = 18. Через месяц вы не вспомните, что такое a.
Путать null и undefined. null — программист намеренно поставил "пусто". undefined — значение ещё не присвоено.

Итого

В этом уроке мы узнали:

Переменная — именованный контейнер для хранения данных в памяти программы.
let — современный способ создать переменную, значение которой можно менять.
const — константа, значение нельзя изменить после присваивания. Используй по умолчанию.
var — устаревший способ, избегайте в новом коде.
Типы данных — number, string, boolean, null, undefined, object, symbol, bigint.
typeof — оператор для определения типа значения.
Шаблонные строки (обратные кавычки + ${}) — удобный способ вставлять переменные в текст.
Используйте === вместо == для сравнения — это защищает от неявных преобразований.

В следующем уроке мы изучим функции — способ упаковать код в многоразовые блоки.

← Anterior Introducción a JavaScript Siguiente → Funciones en JavaScript