← назад к разделу

TypeScript — это надстройка над JavaScript: он добавляет типы, но всё, что выполняется в Node, остаётся обычным JavaScript. Поэтому прежде чем браться за типы, имеет смысл уверенно понимать сам язык: переменные, значения, функции, объекты. Разберём этот минимум на примерах.

Переменные: let и const

В современном JavaScript объявляют переменные двумя словами: const (значение нельзя переназначить) и let (можно). Старое var не используем — у него запутанные правила видимости.

const name = "Anna";   // переназначить нельзя
let count = 0;         // count можно менять
count = count + 1;     // ок

// name = "Bob";       // ошибка: assignment to constant variable

Короткая формула: по умолчанию пиши const, переключайся на let только когда переменную действительно нужно переприсваивать.

Важно: const запрещает переназначить саму переменную, но не запрещает менять содержимое объекта или массива, на который она ссылается.

const user = { age: 20 };
user.age = 21;   // ок: меняем поле, а не саму переменную user

Типы значений

В JavaScript значение всегда принадлежит одному из базовых типов. Для начала достаточно знать эти:

  • number — любое число, целое или дробное (42, 3.14). Отдельного типа для целых нет.
  • string — строка ("hello", 'hi', или шаблонная строка в обратных кавычках).
  • boolean — true или false.
  • null — «значения намеренно нет».
  • undefined — «значение не задано» (переменная объявлена, но ничего не присвоено; поле объекта отсутствует).
  • object — всё составное: объекты, массивы, функции.
const total: number = 100;
const title = "Order";              // string
const isPaid = false;               // boolean
let result;                         // undefined, пока ничего не присвоили
const missing = null;               // намеренно пусто

// шаблонная строка — подстановка через ${...}
const greeting = `Привет, ${title}!`;

Узнать тип значения в рантайме помогает оператор typeof:

typeof total;     // "number"
typeof title;     // "string"
typeof isPaid;    // "boolean"

Разница между null и undefined на практике: undefined обычно появляется само (забыли присвоить, поля нет), а null ставит разработчик, чтобы явно сказать «здесь пусто».

Функции и стрелочные функции

Функция — это блок кода, который принимает аргументы и возвращает значение. Классическая запись через function:

function add(a, b) {
  return a + b;
}

add(2, 3);   // 5

Чаще встречается короткая стрелочная функция (arrow function). Она удобна для небольших операций и для передачи в другие функции:

const add = (a, b) => a + b;          // одно выражение — return подразумевается
const square = (x) => x * x;

// с телом из нескольких строк нужны { } и явный return
const describe = (name) => {
  const upper = name.toUpperCase();
  return `Name: ${upper}`;
};

Стрелки особенно удобны при работе с массивами, где функцию передают как аргумент:

const nums = [1, 2, 3];
const doubled = nums.map((n) => n * 2);   // [2, 4, 6]

Объекты

Объект — это набор пар «ключ — значение». Это основная структура для моделирования данных на бэкенде.

const order = {
  id: 42,
  customer: "Anna",
  paid: false,
};

// доступ к полям
order.id;              // 42
order["customer"];     // "Anna" — то же самое через строковый ключ

// добавление и изменение
order.paid = true;
order.total = 100;     // новое поле

Если поля может не быть, обращение к нему вернёт undefined — это не ошибка, а штатное поведение:

order.discount;   // undefined: такого поля нет

Массивы

Массив — упорядоченный список значений. Индексация с нуля.

const items = ["a", "b", "c"];

items[0];          // "a"
items.length;      // 3
items.push("d");   // добавить в конец → ["a", "b", "c", "d"]

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

const prices = [10, 20, 30];

prices.forEach((p) => console.log(p));         // просто перебрать
const withTax = prices.map((p) => p * 1.2);    // преобразовать каждый → новый массив
const big = prices.filter((p) => p >= 20);     // оставить подходящие → [20, 30]
const sum = prices.reduce((acc, p) => acc + p, 0);  // свернуть в одно значение → 60

map, filter и reduce не меняют исходный массив, а возвращают новый результат — это удобно и предсказуемо.

Деструктуризация

Деструктуризация — короткий способ вытащить поля объекта или элементы массива в отдельные переменные. На бэкенде встречается постоянно: разбор аргументов, ответов, конфигов.

const user = { name: "Anna", age: 20, city: "Moscow" };

// вместо user.name и user.age
const { name, age } = user;
console.log(name, age);   // "Anna" 20

// из массива — по позиции
const coords = [55.7, 37.6];
const [lat, lon] = coords;
console.log(lat, lon);    // 55.7 37.6

Деструктуризацию часто пишут прямо в параметрах функции, чтобы сразу достать нужные поля:

const formatUser = ({ name, city }) => `${name} из ${city}`;

formatUser(user);   // "Anna из Moscow"

Сравнение: == против ===

В JavaScript два оператора сравнения, и это частый источник путаницы.

  • == (нестрогое) сравнивает значения, приводя типы друг к другу. Из-за этого получаются неожиданные результаты.
  • === (строгое) сравнивает без приведения типов: значения должны совпадать и по типу, и по содержимому.
0 == "0";     // true  — строка приведена к числу
0 == false;   // true  — false приведён к 0
"" == false;  // true

0 === "0";    // false — разные типы
0 === false;  // false

Короткая формула: всегда используй === и !==. Приведение типов в == почти никогда не делает то, что ожидаешь, и прячет ошибки. То же правило позже подтвердит и TypeScript.

Отдельно про проверку «значение есть или нет». Сравнение с null через == намеренно считают null и undefined равными:

let value;                 // undefined
value == null;             // true  — поймает и null, и undefined
value === null;            // false — это undefined, а не null

Коротко

  • const по умолчанию, let только при переприсваивании; var не используем.
  • Базовые типы: number, string, boolean, null, undefined, object. Тип значения проверяется через typeof.
  • undefined — «не задано» (появляется само), null — «пусто» (ставит разработчик явно).
  • Функции пишут через function или короче — стрелочными (...) => ...; стрелки удобны для передачи в map/filter/reduce.
  • Объекты — пары «ключ — значение», массивы — упорядоченные списки; map/filter/reduce возвращают новый результат, не меняя исходный.
  • Деструктуризация коротко достаёт поля объекта и элементы массива, в том числе прямо в параметрах функции.
  • Сравнивай только через === / !== — == приводит типы и прячет ошибки.

Что почитать дальше

  • Базовые типы TypeScript — как навесить типы на эту базу и поймать ошибки до запуска.
  • Асинхронность и event loop — Promise, async/await и как Node выполняет код.
  • Модули и npm — import/export и подключение зависимостей.