Какие знаешь встроенные типы в TypeScript?

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

TypeScript имеет богатую систему типов. Разберу основные встроенные типы и их применение.

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

string, number, boolean:

const name: string = "John";
const age: number = 30;
const isActive: boolean = true;

undefined, null:

const nothing: undefined = undefined;
const empty: null = null;

symbol, bigint:

const unique: symbol = Symbol('id');
const huge: bigint = 123n;

any и unknown

// any — отключает проверку типов (избегай!)
const something: any = 42;

// unknown — безопасный any (используй вместо any)
const data: unknown = getData();
if (typeof data === 'string') {
  console.log(data.toUpperCase()); // Безопасно
}

Unions и Literals

// Union типы
type Status = 'loading' | 'success' | 'error';
type ID = string | number;

// Literal типы
const direction: 'up' | 'down' | 'left' | 'right' = 'up';
const statusCode: 200 | 404 | 500 = 200;

// Можно комбинировать
type Response = { status: 'ok'; data: any } | { status: 'error'; error: string };

Arrays и Tuples

// Массивы
const nums: number[] = [1, 2, 3];
const strings: Array<string> = ['a', 'b', 'c'];

// Кортежи (туплы) — фиксированная длина и типы
const pair: [string, number] = ['hello', 42];
const triple: [string, number, boolean] = ['test', 1, true];

// Остальные элементы
const list: [string, ...number[]] = ['id', 1, 2, 3];

// Optional элементы
const optional: [string, number?] = ['test'];

Object типы

// Объект с явными ключами
type User = {
  name: string;
  age: number;
  email?: string; // Optional property
  readonly id: string; // Readonly
};

// Record — создание объекта с известными ключами
type Config = Record<'dev' | 'prod' | 'test', { url: string }>;

// Index signatures — любые ключи строкового типа
type Dictionary = {
  [key: string]: string | number;
};

// Mapped types
type ReadonlyUser = {
  readonly [K in keyof User]: User[K];
};

// Partial, Required, Pick, Omit
type PartialUser = Partial<User>; // Все свойства optional
type RequiredUser = Required<User>; // Все свойства required
type UserPreview = Pick<User, 'name' | 'age'>; // Только эти поля
type UserWithoutId = Omit<User, 'id'>; // Все кроме id

Функции

// Function signatures
type Callback = (data: string) => void;
type AsyncFn = (id: number) => Promise<User>;

// Function interface
interface Logger {
  (message: string, level?: 'info' | 'error'): void;
}

// Перегрузки функций (function overloads)
function parseValue(value: string): string;
function parseValue(value: number): number;
function parseValue(value: string | number): string | number {
  return value;
}

// Generic функции
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { name: 'John', age: 30 };
const name = getProperty(user, 'name'); // string

Generics

// Основы
interface Box<T> {
  contents: T;
}

const stringBox: Box<string> = { contents: 'hello' };
const numberBox: Box<number> = { contents: 42 };

// Constraints
interface HasId {
  id: string;
}

function getObjectId<T extends HasId>(obj: T): string {
  return obj.id;
}

// Multiple generics
type Pair<K, V> = {
  key: K;
  value: V;
};

// Generic with default
type Container<T = unknown> = {
  data: T;
};

// keyof constraint
function pickProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

Union и Intersection Types

// Union — или
type Result = string | number | boolean;

// Intersection — и
type Admin = User & { role: 'admin'; permissions: string[] };

// Combining
type Response<T> = { success: true; data: T } | { success: false; error: string };

Conditional Types

// Ternary для типов
type IsString<T> = T extends string ? true : false;

type A = IsString<'hello'>; // true
type B = IsString<42>; // false

// Практический пример
type Flatten<T> = T extends Array<infer U> ? U : T;

type Str = Flatten<string[]>; // string
type Num = Flatten<number>; // number

// Distributive conditional types
type ToArray<T> = T extends any ? T[] : never;
type StrOrNumArray = ToArray<string | number>; // string[] | number[]

Type Guards и Type Predicates

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

const data: unknown = 'test';
if (isString(data)) {
  console.log(data.toUpperCase()); // data — string
}

// Custom type guard
function hasId(obj: any): obj is { id: string } {
  return obj && typeof obj.id === 'string';
}

Utility Types (встроенные помощники)

// Partial<T> — все свойства optional
type OptionalUser = Partial<User>;

// Required<T> — все свойства required
type MandatoryUser = Required<{ name?: string }>;

// Readonly<T> — все свойства readonly
type FrozenUser = Readonly<User>;

// Record<K, T> — объект с ключами K и значениями T
type Weekdays = Record<'mon' | 'tue' | 'wed', boolean>;

// Pick<T, K> — выбрать поля K из T
type UserBrief = Pick<User, 'name' | 'email'>;

// Omit<T, K> — всё кроме K
type UserWithoutPassword = Omit<User, 'password'>;

// Exclude<T, U> — исключить U из T
type Status = 'success' | 'error' | 'pending';
type ErrorStatus = Exclude<Status, 'success'>; // 'error' | 'pending'

// Extract<T, U> — выбрать U из T
type SuccessStatus = Extract<Status, 'success' | 'pending'>; // 'success' | 'pending'

// ReturnType<T> — тип возврата функции
type Fn = () => Promise<string>;
type RetVal = ReturnType<Fn>; // Promise<string>

// Parameters<T> — типы параметров функции
type Params = Parameters<Fn>;

// InstanceType<T> — тип экземпляра конструктора
class MyClass {
  constructor(public value: string) {}
}
type Instance = InstanceType<typeof MyClass>; // MyClass

never и void

// void — функция ничего не возвращает
function log(message: string): void {
  console.log(message);
}

// never — функция никогда не возвращает
function throwError(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {}
}

// never в unions — исчезает
type Options = string | number | never; // string | number

Const assertions

// Обычный объект
const obj = { role: 'admin' }; // type: { role: string }

// Const assertion
const constObj = { role: 'admin' } as const; // type: { readonly role: 'admin' }

// Очень полезно для пакета констант
const ROLES = {
  admin: 'admin',
  user: 'user',
  guest: 'guest',
} as const;

type Role = typeof ROLES[keyof typeof ROLES]; // 'admin' | 'user' | 'guest'

TypeScript имеет мощную систему типов. Ключ к овладению — понимание Generics, Conditional Types и Utility Types. Практикуй ежедневно на реальных проектах!