Шпаргалка по TypeScript

СПРАВОЧНИК

Назначение

Справочник-шпаргалка по TypeScript — типы, синтаксис, стандартная библиотека, типовые паттерны. Не заменяет пошаговое обучение.

Учебный раздел (18 статей + практика): TypeScript — о разделе. Карта "блок 301 → учебная статья": индекс 5-10/2.

Краткое пояснение

Кратко о надмножестве.

Справочные таблицы

Содержание справочника

1. Основы типизации
2. Составные типы
3. Объединения и пересечения
4. Функции
5. Интерфейсы
6. Классы
7. Утилитарные типы
8. Расширенные возможности типов
9. Модули и пространства имен
10. Декларации
11. Конфигурация TypeScript (tsconfig.json)
12. Декораторы
13. Работа с DOM и окружением
14. Интеграция с фреймворками
15. Распространённые паттерны
16. Лучшие практики
17. Инструменты и CLI
18. Расширение TypeScript

1. Основы типизации

Как создавать типы и что это даёт

В TypeScript типы создают несколькими способами. Чаще всего используют type, interface, typeof, keyof, дженерики и встроенные utility-типы.

Что это даёт на практике:

ошибки ловятся на этапе компиляции, до запуска кода;
автодополнение в IDE становится точнее;
рефакторинг проходит безопаснее;
контракт между модулями становится явным.

Способы создания типов

Через type

type User = {
  id: string;
  email: string;
  isActive: boolean;
};

Подходит для объединений, пересечений, алиасов и вычисляемых типов.

Через interface

interface Product {
  sku: string;
  price: number;
}

Подходит для публичных контрактов объектов и class API.

Через typeof по существующему значению

const defaults = {
  retries: 3,
  timeoutMs: 5000
};

type Defaults = typeof defaults;
// { retries: number; timeoutMs: number }

Позволяет не дублировать структуру вручную.

Через keyof для набора ключей

type UserField = keyof User;
// "id" | "email" | "isActive"

Полезно для безопасной работы с именами полей.

Примитивные типы

TypeScript поддерживает следующие примитивные типы:

string — строка текста
number — числовое значение (включая целые и дробные)
boolean — логическое значение (true или false)
bigint — целое число произвольной длины
symbol — уникальный и неизменяемый идентификатор
undefined — значение, присваиваемое переменной, которая объявлена, но не инициализирована
null — явное отсутствие значения

Специальные типы

any — отключает проверку типов; переменная может принимать любое значение
unknown — безопасная альтернатива any; требует проверки перед использованием
never — тип, представляющий значения, которые никогда не возникают (например, функция, выбрасывающая ошибку или зацикливающаяся)
void — тип, указывающий отсутствие возвращаемого значения у функции

Тип `object`

Тип object описывает любой непримитивный тип. Он не включает null.

let obj: object = { a: 1 };
obj = [1, 2, 3];
obj = () => {};

Этот тип редко используется напрямую. Предпочтение отдается более точным описаниям структуры.

2. Составные типы

Объектные типы

Объектный тип описывает форму объекта через перечисление свойств и их типов:

type User = {
  id: number;
  name: string;
  isActive: boolean;
};

Свойства могут быть опциональными:

type Config = {
  theme?: 'light' | 'dark';
  timeout?: number;
};

Свойства могут быть только для чтения:

type Point = {
  readonly x: number;
  readonly y: number;
};

Массивы

Массивы описываются двумя способами:

Синтаксис T[]:

  let numbers: number[] = [1, 2, 3];

Синтаксис Array<T>:

  let strings: Array<string> = ['a', 'b'];

Кортежи (Tuples)

Кортеж — массив фиксированной длины с известными типами элементов:

let rgb: [number, number, number] = [255, 128, 0];

Кортежи могут содержать опциональные элементы и остаточные параметры:

type HTTPResponse = [number, string?, ...string[]];

Коллекции и структуры данных

TypeScript типизирует не только примитивы и объекты, но и стандартные коллекции JavaScript. Ниже — основные варианты и типичные сценарии использования.

`Array<T>`

Массив для однотипных элементов, когда важны порядок и перебор:

const users: string[] = ['Ann', 'Bob', 'Max'];
const ages: Array<number> = [20, 25, 31];

Используйте, если нужен список значений одного типа.

`Tuple`

Кортеж подходит, когда фиксированы длина и порядок элементов:

type Point2D = [number, number];
type ApiResult = [status: number, body: string];

Используйте для координат, пар значений, результатов вида [data, error].

`Record<K, V>`

Тип словаря "ключ -> значение" на базе объекта:

type Role = 'admin' | 'editor' | 'user';
type Permissions = Record<Role, string[]>;

Используйте, когда ключи известны заранее и обычно строковые/литеральные.

`Map<K, V>`

Коллекция пар "ключ -> значение" с поддержкой любых типов ключей:

const sessions = new Map<number, { token: string }>();
sessions.set(101, { token: 'abc' });

Чаще выбирают Map, если:

ключи не ограничены строками;
нужны частые вставки и удаления;
важен предсказуемый порядок вставки.

`Set<T>`

Коллекция уникальных значений:

const uniqueIds = new Set<number>([1, 2, 2, 3]); // 1, 2, 3
uniqueIds.add(4);

Удобно для дедупликации и быстрых проверок наличия значения.

`WeakMap<K extends object, V>` и `WeakSet<T extends object>`

"Слабые" коллекции, которые не мешают сборщику мусора удалять объекты-ключи:

const cache = new WeakMap<object, { parsed: boolean }>();
const visited = new WeakSet<object>();

Полезны для метаданных объектов и временных кешей, привязанных к жизненному циклу объекта.

Что выбирать на практике

Array<T> — просто список элементов одного типа.
Tuple — фиксированная структура по позициям.
Record<K, V> — словарь с заранее известными ключами.
Map<K, V> — динамический словарь с гибкими ключами.
Set<T> — множество уникальных значений.
WeakMap/WeakSet — временные связи с объектами без риска утечек памяти.

3. Объединения и пересечения

Объединение типов (`|`)

Объединение позволяет значению соответствовать одному из нескольких типов:

type ID = string | number;
type Status = 'loading' | 'success' | 'error';

Пересечение типов (`&`)

Пересечение объединяет несколько типов в один:

type A = { a: string };
type B = { b: number };
type C = A & B; // { a: string; b: number }

4. Функции

Типизация параметров и возврата

function greet(name: string): string {
  return `Hello, ${name}`;
}

Функция может не возвращать значение:

function log(message: string): void {
  console.log(message);
}

Необязательные и параметры по умолчанию

function createUser(name: string, age?: number) { /* ... */ }
function multiply(a: number, b: number = 1) { return a * b; }

Типы функций

Тип функции описывает сигнатуру:

type BinaryOperation = (x: number, y: number) => number;
const add: BinaryOperation = (a, b) => a + b;

Перегрузка функций

TypeScript поддерживает перегрузку функций через декларации:

function format(value: string): string;
function format(value: number): string;
function format(value: string | number): string {
  return String(value);
}

5. Интерфейсы

Интерфейсы описывают контракты для объектов, классов и функций.

Базовый интерфейс

interface Person {
  name: string;
  age: number;
}

Расширение интерфейсов

interface Employee extends Person {
  department: string;
}

Опциональные и readonly-свойства

interface Options {
  timeout?: number;
  readonly retries: number;
}

Индексные сигнатуры

interface Dictionary {
  [key: string]: number;
}

Вызов и конструктор

interface Callable {
  (input: string): boolean;
}

interface Constructable {
  new (name: string): Instance;
}

6. Классы

Базовое объявление

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  move() { console.log(`${this.name} moves`); }
}

Модификаторы доступа

public — доступен везде (по умолчанию)
private — доступен только внутри класса
protected — доступен внутри класса и его потомков

Параметры конструктора

class Point {
  constructor(public x: number, public y: number) {}
}

Абстрактные классы

abstract class Shape {
  abstract getArea(): number;
  render() { /* общая логика */ }
}

Статические члены

class MathUtils {
  static PI = 3.14159;
  static double(x: number) { return x * 2; }
}

Реализация интерфейсов

class Bird implements Flyable {
  fly() { /* ... */ }
}

7. Утилитарные типы

TypeScript предоставляет встроенные утилитарные типы для трансформации других типов.

`Partial<T>`

Делает все свойства типа T опциональными.

type PartialUser = Partial<User>; // { id?: number; name?: string; ... }

`Required<T>`

Делает все свойства обязательными.

`Readonly<T>`

Делает все свойства только для чтения.

`Record<K, T>`

Создает объектный тип с ключами типа K и значениями типа T.

type StatusCodeMap = Record<number, string>;

`Pick<T, K>`

Выбирает подмножество свойств из T по ключам K.

type NameOnly = Pick<User, 'name'>;

`Omit<T, K>`

Исключает указанные свойства из типа.

type WithoutId = Omit<User, 'id'>;

Комбо-паттерн: безопасное обновление полей модели

Omit, keyof и дженерик-функция часто используются вместе, чтобы запретить изменение системных полей и сохранить связь между выбранным ключом и типом значения.

Код ITЗагрузка примера кода…

`Exclude<T, U>`

Исключает из T все типы, совместимые с U.

type NonNullable = Exclude<string | null | undefined, null | undefined>;

`Extract<T, U>`

Извлекает из T только те типы, которые совместимы с U.

`NonNullable<T>`

Удаляет null и undefined из объединения.

`ReturnType<T>`

Извлекает тип возвращаемого значения функции.

type R = ReturnType<() => string>; // string

`Parameters<T>`

Получает кортеж типов параметров функции.

type P = Parameters<(a: number, b: string) => void>; // [number, string]

`ConstructorParameters<T>`

Получает типы параметров конструктора.

`InstanceType<T>`

Получает тип экземпляра класса.

`ThisType<T>`

Указывает контекст this в объектных литералах.

8. Расширенные возможности типов

Операторы типов

Оператор	Синтаксис	Назначение
Запрос типа	`typeof x`	Тип переменной или свойства
Ключи	`keyof T`	Union всех ключей объекта
Индексация	`T[K]`	Тип поля `K` в `T`
Поиск по union	`T[number]`	Элемент массива/кортежа
Пересечение ключей	`K & keyof T`	Ограничение ключей
Условный	`T extends U ? X : Y`	Выбор типа по совместимости
Infer	`infer R`	Вывод типа внутри conditional
Mapped	`{ [K in keyof T]: … }`	Преобразование всех полей
Template literal	`prefix-${K}`	Строковые шаблоны типов

type User = { id: string; name: string; role: 'admin' | 'user' };
type UserKeys = keyof User;                    // 'id' | 'name' | 'role'
type UserName = User['name'];                  // string
type ReadonlyUser = { readonly [K in keyof User]: User[K] };
type RoleKey = `role-${User['role']}`;         // 'role-admin' | 'role-user'

Условные типы

type IsString<T> = T extends string ? true : false;

Распределительные условные типы

Автоматически применяются к каждому элементу объединения.

Инференс в условных типах

type ReturnType<T> = T extends (...args: any) => infer R ? R : never;

Mapped Types

Создание новых типов на основе существующих с преобразованием ключей или значений.

type Nullable<T> = { [P in keyof T]: T[P] | null };

Сопоставленные типы и обобщённая индексация

Сопоставленные типы (mapped types) проходят по ключам типа и строят новый тип по шаблону. Обобщённая индексация связывает ключ и значение через T[K], где K extends keyof T.

Код ITЗагрузка примера кода…

Здесь тип WebhookHandler<E> гарантирует соответствие между именем события и формой payload. Если обратиться к полю из другого события, компилятор сразу сообщает о проблеме.

Особенности:

PayloadMap[E] даёт точный тип нагрузки для выбранного события;
одна и та же функция-обработчик масштабируется на десятки событий без any;
ошибки в названиях полей и несоответствиях контракта ловятся до запуска.

Template Literal Types

Позволяют создавать строки на основе шаблонов:

type EventName = `${'click' | 'hover'}-${'button' | 'link'}`;
// 'click-button' | 'click-link' | 'hover-button' | 'hover-link'

Key Remapping

В mapped types можно переименовывать ключи:

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};

9. Модули и пространства имен

Модули ES

TypeScript использует стандартные модули ES:

// math.ts
export const PI = 3.14159;
export function add(a: number, b: number) { return a + b; }

// main.ts

import { PI, add } from './math';

Пространства имен

namespace Utils {
  export function log(msg: string) { console.log(msg); }
}

Пространства имён рекомендуются только для глобальных библиотек или legacy-кода. В новых проектах — ES-модули (import/export).

Слияние деклараций (declaration merging)

interface с одинаковым именем объединяются:

interface Box { width: number; }
interface Box { height: number; }
// Box = { width: number; height: number; }

interface Box { scale(factor: number): void; } // merge с методом

namespace может дополнять class, function, enum:

function buildLabel(name: string): string {
  return buildLabel.prefix + name + buildLabel.suffix;
}
namespace buildLabel {
  export let prefix = 'Hello, ';
  export let suffix = '!';
}

type не сливается — для alias используйте одно объявление.

10. Декларации

Глобальные декларации

declare var VERSION: string;
declare function initialize(): void;

Декларации модулей

declare module 'my-library' {
  export function doSomething(): void;
}

Расширение существующих интерфейсов

interface Window {
  myCustomProp: string;
}

Правила `.d.ts` для сторонних JS-модулей

Задача	Подход
Типы для npm-пакета без `.d.ts`	`@types/имя` из DefinitelyTyped или свой `declare module`
UMD / глобальная переменная	`export as namespace Lib;` + `declare global`
Расширение чужого модуля	`declare module 'lib' { export … }` (augmentation)
Только типы, без JS	`"types"` / `"typings"` в `package.json` → `index.d.ts`

Пример augmentation:

// types/express.d.ts

import 'express';

declare module 'express-serve-static-core' {
  interface Request {
    userId?: string;
  }
}

Поля declare не генерируют JS — только проверка типов. interface допускает merge; type и enum — нет.

11. Конфигурация TypeScript (`tsconfig.json`)

Полный список опций компилятора:

Основные настройки

target — версия ECMAScript (например, "ES2020", "ES2022")
module — система модулей ("commonjs", "es2020", "esnext")
lib — библиотеки, включаемые в компиляцию (["DOM", "ES2022"])
outDir — директория для скомпилированного JS
rootDir — корневая директория исходников
declaration — генерировать .d.ts файлы
sourceMap — генерировать source maps

Проверка типов

strict — включает все строгие проверки
noImplicitAny — запрещает неявный any
strictNullChecks — требует явной обработки null/undefined
strictFunctionTypes — усиливает проверку типов функций
strictBindCallApply — строгая типизация методов bind, call, apply
strictPropertyInitialization — требует инициализации всех свойств класса
noImplicitThis — запрещает неявный this типа any
alwaysStrict — добавляет "use strict" в каждый файл

Флаги безопасности `compilerOptions`

Флаг strict: true включает группу проверок ниже. Отдельные флаги можно включать по одному при постепенной миграции legacy-кода.

Флаг	Что проверяет	Типичная ошибка без флага
`strictNullChecks`	`null`/`undefined` отдельно от базового типа	`obj.foo` на пустом объекте
`noImplicitAny`	Запрет неявного `any`	Параметр без типа → `any`
`strictFunctionTypes`	Контрвариантность параметров функций	Небезопасная передача callback
`strictBindCallApply`	Типы аргументов у `bind`/`call`/`apply`	Неверное число аргументов
`strictPropertyInitialization`	Поля класса инициализированы	`undefined` у `readonly` поля
`noImplicitThis`	Явный тип `this` в функциях	`this` как `any` в callback
`useUnknownInCatchVariables`	`catch (e)` имеет тип `unknown`	Обращение к `e.message` без проверки
`noUncheckedIndexedAccess`	Индекс массива/запись → `T \| undefined`	Доступ `[0]` без проверки
`exactOptionalPropertyTypes`	`undefined` ≠ "свойства нет"	Лишний ключ со значением `undefined`
`noImplicitReturns`	`return` во всех ветках функции	Забытый `return` в `if`
`noFallthroughCasesInSwitch`	Запрет провала между `case`	Два `case` без `break`
`noUnusedLocals` / `noUnusedParameters`	Мёртвый код	Неиспользуемые переменные

Рекомендуемый минимум для новых проектов:

{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true
  }
}

Полный список — typescriptlang.org/tsconfig.

Модули и разрешение

moduleResolution — стратегия разрешения модулей ("node", "classic")
baseUrl — базовый URL для абсолютных импортов
paths — маппинг путей
resolveJsonModule — разрешить импорт JSON-файлов
esModuleInterop — улучшает совместимость с CommonJS

JSX

jsx — режим обработки JSX ("preserve", "react", "react-jsx")
jsxFactory — функция для создания элементов (по умолчанию React.createElement)
jsxFragmentFactory — фабрика для фрагментов

Экспериментальные возможности

experimentalDecorators — поддержка декораторов
emitDecoratorMetadata — генерация метаданных для декораторов

Отладка и производительность

incremental — инкрементальная сборка
tsBuildInfoFile — файл для хранения информации о сборке
composite — поддержка проектных ссылок

Project references (монорепозиторий)

Включите в базовом tsconfig:

{
  "compilerOptions": {
    "composite": true,
    "declaration": true,
    "declarationMap": true,
    "incremental": true
  }
}

В зависимом пакете:

{
  "references": [{ "path": "../shared" }]
}

Команды:

Команда	Действие
`tsc -b`	Сборка всего графа references
`tsc -b --clean`	Очистка артефактов
`tsc -b -w`	Watch-режим для monorepo

Учебный разбор — 30.md § Monorepo.

Запреты и предупреждения

noUnusedLocals — предупреждать о неиспользуемых локальных переменных
noUnusedParameters — предупреждать о неиспользуемых параметрах
noImplicitReturns — требовать явный return во всех ветках
noFallthroughCasesInSwitch — запрет провалов в switch
allowUnreachableCode — разрешить недостижимый код
exactOptionalPropertyTypes — различать undefined и отсутствие свойства

12. Декораторы

Декораторы — экспериментальная возможность, позволяющая добавлять метаданные и изменять поведение классов, методов, свойств и параметров.

Включение декораторов

В tsconfig.json требуется:

{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

Типы декораторов

Классовые декораторы:

  function sealed(constructor: Function) {
    Object.seal(constructor);
    Object.seal(constructor.prototype);
  }

  @sealed
  class Greeter { /* ... */ }

Метод-декораторы:

  function readonly(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    descriptor.writable = false;
  }

  class Math {
    @readonly
    double(x: number) { return x * 2; }
  }

Свойства-декораторы:

  function format(template: string) {
    return function (target: any, propertyKey: string) {
      // можно сохранить метаданные через Reflect
    };
  }

  class User {
    @format("Hello, %s")
    name: string;
  }

Параметр-декораторы:

  function logParameter(target: any, methodName: string, paramIndex: number) {
    // логика регистрации параметра
  }

  class Greeter {
    greet(@logParameter name: string) { /* ... */ }
  }

Метаданные

С включённой опцией emitDecoratorMetadata, TypeScript генерирует типы параметров и возвращаемых значений как метаданные, доступные через Reflect.getMetadata.

13. Работа с DOM и окружением

Глобальные типы

TypeScript автоматически подключает типы для DOM, если в lib указано "DOM".

Пример:

const button = document.getElementById('submit') as HTMLButtonElement;
button.addEventListener('click', () => { /* ... */ });

Определение глобальных переменных

// global.d.ts
interface Window {
  __APP_VERSION__: string;
}

Теперь window.__APP_VERSION__ доступен без ошибок.

Работа с событиями

document.addEventListener('keydown', (event: KeyboardEvent) => {
  if (event.key === 'Enter') { /* ... */ }
});

14. Интеграция с фреймворками

React

Используются файлы .tsx
Компоненты типизируются через React.FC<Props>
Хуки (useState, useEffect) выводят типы автоматически
Пропсы описываются интерфейсами или типами

interface ButtonProps {
  label: string;
  onClick: () => void;
}

const Button: React.FC<ButtonProps> = ({ label, onClick }) => (
  <button onClick={onClick}>{label}</button>
);

Vue.js

Поддержка через defineComponent
Пропсы описываются в props с указанием типа
Композиционный API использует ref, computed с выводом типов

import { defineComponent, PropType } from 'vue';

export default defineComponent({
  props: {
    title: { type: String as PropType<string>, required: true }
  },
  setup(props) {
    // props.title — string
  }
});

Angular

Полная поддержка TypeScript "из коробки"
Декораторы @Component, @Injectable используют метаданные
Типизация шаблонов через строгую проверку

Node.js

Устанавливается пакет @types/node
Глобальные объекты — process, global, Buffer
Модули CommonJS и ES совместимы при правильной настройке

import * as fs from 'fs';

fs.readFile('file.txt', 'utf8', (err, data) => { /* ... */ });

15. Распространённые паттерны

Защита от null/undefined (Defensive Programming)

function processUser(user: User | null) {
  if (!user) return;
  // user теперь User
}

Discriminated Unions

type Success = { status: 'success'; data: string };
type Failure = { status: 'error'; message: string };
type Result = Success | Failure;

function handle(result: Result) {
  if (result.status === 'success') {
    // result.data доступен
  }
}

Тотальность (exhaustive check)

Проверка полноты охвата union через never в default:

Код ITЗагрузка примера кода…

Новый вариант в Action без ветки в switch → ошибка компиляции на _check.

Option и Result

Код ITЗагрузка примера кода…

Паттерн	Когда использовать
`T \| null`	Простые API, один "пустой" исход
`Option<T>`	Явное "значения нет" без исключения
`Result<T, E>`	Нужен код/тип ошибки в контракте
`throw`	Невосстановимые сбои инфраструктуры

Учебный разбор — 30.md § Обработка ошибок.

Type Guards

function isString(value: unknown): value is string {
  return typeof value === 'string';
}

if (isString(input)) {
  // input — string
}

Branding Types (Nominal Typing Emulation)

type UserID = string & { readonly brand: unique symbol };
const createUserID = (id: string): UserID => id as UserID;

Immutability

Использование Readonly<T>, readonly массивов и spread-операторов:

const newState = { ...state, count: state.count + 1 };

16. Лучшие практики

Всегда включайте strict: true
Избегайте any; используйте unknown при работе с внешними данными
Предпочитайте interface для публичных API, type — для утилит и union-типов
Используйте утилитарные типы вместо ручного копирования структур
Пишите тесты с учётом типов (Jest + ts-jest)
Разделяйте бизнес-логику и типы от инфраструктурного кода
Не используйте as без необходимости; предпочитайте проверки типов

17. Инструменты и CLI

Компилятор `tsc`

Основные команды:

tsc --init — создаёт tsconfig.json
tsc --watch — отслеживает изменения и перекомпилирует
tsc --noEmit — только проверка типов, без генерации JS
tsc file.ts — компиляция одного файла

Примечание по развитию экосистемы: для ветки TypeScript 7.x анонсирован нативный компилятор на Go. Для больших проектов это важно из-за лучшего использования многоядерных CPU и ускорения тип-проверки/сборки. При внедрении в проде ориентируйтесь на официальные release notes и совместимость вашего toolchain.

ESLint + TypeScript

Используется @typescript-eslint/parser
Правила — no-explicit-any, strict-boolean-expressions, prefer-readonly

Prettier

Форматирование кода с поддержкой TypeScript и JSX.

TypeScript Playground

Онлайн-редактор на typescriptlang.org/play

18. Расширение TypeScript

AST и трансформеры

TypeScript предоставляет API для анализа и модификации Abstract Syntax Tree.

Пример использования:

import * as ts from 'typescript';

const source = ts.createSourceFile('test.ts', 'const x = 1;', ts.ScriptTarget.Latest);

Это используется в:

Кастомных линтерах
Кодогенераторах
Babel-плагинах с поддержкой TS
Framework-specific компиляторах (например, Angular)

Language Service API

Позволяет создавать IDE-функции — автодополнение, навигацию, рефакторинг.

19. Полное API: Основы

Введение в TypeScript

TypeScript — надмножество JavaScript со статической типизацией: вы пишете JS-подобный код, а проверка типов происходит до запуска.

Компиляция

tsc преобразует .ts/.tsx в JavaScript и проверяет контракты типов.

Типы данных

База — string, number, boolean, bigint, symbol, null, undefined, object, а также unknown, never, void.

Изменение значений

Тип переменной фиксируется выводом типа/аннотацией; значение можно менять только в пределах совместимого типа.

Операции

Операции над данными проверяются типами: например, нельзя вызывать строковые методы на number.

Массивы

Типизация массивов: T[] или Array<T>.

Объекты

Объекты описываются через type/interface, что фиксирует форму данных.

Контроль типа переменной в объекте

Через narrowing (typeof, in, instanceof) TypeScript сужает типы в ветках.

Контроль структуры объекта

Проверка обязательных/опциональных полей и readonly-контрактов.

Контроль типов значений объекта

Каждое поле имеет свой тип; неправильные присваивания блокируются компилятором.

Цикл for

Обычный индексный цикл подходит для массивов и диапазонов.

Цикл for-of

Итерация по значениям (Array, Set, Map.keys()/values() и т.д.).

Цикл for-in

Итерация по ключам объекта; часто сочетается с keyof.

Функции

Параметры и return-тип аннотируются явно или выводятся автоматически.

Пустой результат функции

void означает "ничего полезного не возвращается".

Тип any

any отключает проверку типов; использовать только как временный компромисс.

Тип any в массивах

any[] убирает безопасность по всем элементам массива; лучше unknown[] + проверки.

Объединение типов

A | B позволяет переменной принимать одно из нескольких значений/типов.

Псевдонимы типов

type Name = ... даёт читаемые и переиспользуемые контракты.

Тип строкового литерала

Ограничение значения конкретными строками: 'draft' | 'active'.

Псевдонимы для объединения строк

Комбинация type + string union для безопасных статусов, ролей, событий.

20. Полное API: Кортежи

Введение в кортежи

Кортеж — фиксированная последовательность с типом на каждой позиции.

Изменение кортежа

Изменять можно только значения, совместимые с типом позиции.

Кортеж для чтения

readonly [A, B] запрещает мутации.

Необязательные элементы кортежей

[A, B?] описывает опциональные позиции.

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

const [x, y] = tuple сохраняет типы элементов.

Заполнение кортежа

При инициализации важны порядок и длина; иначе ошибка проверки.

21. Полное API: Перечисления

Введение в перечисления

enum задаёт именованный набор констант.

Получение по ключу

Доступ к значению: EnumName.Member.

Получение по значению

Для numeric enum доступно обратное отображение.

Перечисление как тип

Поле можно ограничить конкретным enum.

Явные ключи

Каждому элементу задаётся конкретное значение вручную.

Упрощенные ключи

Numeric enum умеет автоинкремент.

Строковые перечисления

String enum удобен для API-контрактов и логов.

22. Полное API: Встроенные типы и структуры

Введение в встроенные типы

TypeScript использует стандартные JS-объекты и их typed-API.

Дата

Date типизируется из коробки (toISOString, getTime и т.д.).

Регулярки

RegExp и методы строк поддерживают строгую типизацию аргументов.

Тип HTMLElement

Для DOM есть точные типы — HTMLElement, HTMLInputElement, Event.

Коллекции

Map<K,V>, Set<T>, WeakMap, WeakSet типизируются дженериками.

Структура объекта

Объект проектируется как контракт с явными полями.

Необязательные свойства объекта

field?: T разрешает отсутствие свойства.

Интерфейсы (в разработке)

interface удобен для публичных API и расширяемых контрактов.

Массивы в объектах

Поля-коллекции описываются как items: Item[].

Интерфейс как тип объекта с массивом

Интерфейс легко описывает вложенные массивы и связи сущностей.

Сложные объекты

Составные структуры собираются через nested-типы и utility-типы.

Объекты в объектах

Вложенность моделируется через отдельные интерфейсы/алиасы.

Массивы объектов

Array<Entity> — основной паттерн для списков данных из API.

23. Полное API: Функции

Количество параметров

Сигнатура функции строго фиксирует число и типы аргументов.

Необязательные параметры

param?: T делает аргумент необязательным.

Значения параметров по умолчанию

(x = 1) задаёт default и помогает выводу типа.

Rest параметры

(...args: T[]) собирает произвольное число однотипных аргументов.

Тип функций

Тип функции задаётся как (a: A) => B.

Свой тип с функцией

Часто делают alias: type Handler = (e: Event) => void.

Функции-коллбэки (задачи)

Callback-типы обеспечивают безопасную передачу логики между модулями.

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

Arrow functions краткие и хорошо выводятся по контексту.

24. Мини-шпаргалка по теме "полное API"

Код ITЗагрузка примера кода…

Этот блок покрывает ключевые элементы из вашего списка:

литеральные union-типы;
readonly-кортеж;
интерфейс с необязательным полем;
enum;
типизированную функцию с rest-параметрами.

В подборках

Статья входит в тематические подборки и блок "С чего начать?" на главной. Соседние шаги того же маршрута:

Справочники — Справочник по Angular, Справочник по Ext JS, Справочник по Vue.js, Справочник по Django, Справочник по React, Справочник по модулю Turtle.

Назначение​

Краткое пояснение​

Справочные таблицы​

Содержание справочника​

1. Основы типизации​

Как создавать типы и что это даёт​

Способы создания типов​

Примитивные типы​

Специальные типы​

Тип object​

2. Составные типы​

Объектные типы​

Массивы​

Кортежи (Tuples)​

Коллекции и структуры данных​

Array<T>​

Tuple​

Record<K, V>​

Map<K, V>​

Set<T>​

WeakMap<K extends object, V> и WeakSet<T extends object>​

Что выбирать на практике​

3. Объединения и пересечения​

Объединение типов (|)​

Пересечение типов (&)​

4. Функции​

Типизация параметров и возврата​

Необязательные и параметры по умолчанию​

Типы функций​

Перегрузка функций​

5. Интерфейсы​

Базовый интерфейс​

Расширение интерфейсов​

Опциональные и readonly-свойства​

Индексные сигнатуры​

Вызов и конструктор​

6. Классы​

Базовое объявление​

Модификаторы доступа​

Параметры конструктора​

Абстрактные классы​

Статические члены​

Реализация интерфейсов​

7. Утилитарные типы​

Partial<T>​

Required<T>​

Readonly<T>​

Record<K, T>​

Pick<T, K>​

Omit<T, K>​

Комбо-паттерн: безопасное обновление полей модели​

Exclude<T, U>​

Extract<T, U>​

NonNullable<T>​

ReturnType<T>​

Parameters<T>​

ConstructorParameters<T>​

InstanceType<T>​

ThisType<T>​

8. Расширенные возможности типов​

Операторы типов​

Условные типы​

Распределительные условные типы​

Инференс в условных типах​

Mapped Types​

Сопоставленные типы и обобщённая индексация​

Template Literal Types​

Key Remapping​

9. Модули и пространства имен​

Модули ES​

Пространства имен​

Слияние деклараций (declaration merging)​

10. Декларации​

Глобальные декларации​

Декларации модулей​

Расширение существующих интерфейсов​

Правила .d.ts для сторонних JS-модулей​

11. Конфигурация TypeScript (tsconfig.json)​

Основные настройки​

Проверка типов​

Назначение

Краткое пояснение

Справочные таблицы

Содержание справочника

1. Основы типизации

Как создавать типы и что это даёт

Способы создания типов

Примитивные типы

Специальные типы

Тип `object`

2. Составные типы

Объектные типы

Массивы

Кортежи (Tuples)

Коллекции и структуры данных

`Array<T>`

`Tuple`

`Record<K, V>`

`Map<K, V>`

`Set<T>`

`WeakMap<K extends object, V>` и `WeakSet<T extends object>`

Что выбирать на практике

3. Объединения и пересечения

Объединение типов (`|`)

Пересечение типов (`&`)

4. Функции

Типизация параметров и возврата

Необязательные и параметры по умолчанию

Типы функций

Перегрузка функций

5. Интерфейсы

Базовый интерфейс

Расширение интерфейсов

Опциональные и readonly-свойства

Индексные сигнатуры

Вызов и конструктор

6. Классы

Базовое объявление

Модификаторы доступа

Параметры конструктора

Абстрактные классы

Статические члены

Реализация интерфейсов

7. Утилитарные типы

`Partial<T>`

`Required<T>`

`Readonly<T>`

`Record<K, T>`

`Pick<T, K>`

`Omit<T, K>`

Комбо-паттерн: безопасное обновление полей модели

`Exclude<T, U>`

`Extract<T, U>`

`NonNullable<T>`

`ReturnType<T>`

`Parameters<T>`

`ConstructorParameters<T>`

`InstanceType<T>`

`ThisType<T>`

8. Расширенные возможности типов

Операторы типов

Условные типы

Распределительные условные типы

Инференс в условных типах

Mapped Types

Сопоставленные типы и обобщённая индексация

Template Literal Types

Key Remapping

9. Модули и пространства имен

Модули ES

Пространства имен

Слияние деклараций (declaration merging)

10. Декларации

Глобальные декларации

Декларации модулей

Расширение существующих интерфейсов

Правила `.d.ts` для сторонних JS-модулей

11. Конфигурация TypeScript (`tsconfig.json`)

Основные настройки

Проверка типов