Типы в TypeScript

function formatPrice(price: number): string {
    return `$${price.toFixed(2)}`;
}
 
// Ошибка: аргумент типа string не может быть присвоен параметру типа number
formatPrice("100");

let value: number = 42;
value = "Hello";       // Ошибка: тип string не может быть присвоен типу number

interface Named {
    name: string;
}
 
class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
}
 
// Допустимо, т.к. Person имеет свойство name
const p: Named = new Person("Alice");

let name: string = "Александр";
let greeting: string = `Привет, ${name}!`;  // Шаблонные строки также поддерживаются

let decimal: number = 42;
let float: number = 3.14;
let hex: number = 0xf00d;      // шестнадцатеричная запись
let binary: number = 0b1010;   // двоичная запись

let isCompleted: boolean = false;
isCompleted = true;

let dynamicValue: any = 4;
dynamicValue = "строка";      // Допустимо
dynamicValue = { key: "value" }; // Тоже допустимо

// Функция с типизированными параметрами и возвращаемым значением
function calculateTotal(price: number, quantity: number): number {
    return price * quantity;
}
 
// Объект с указанием типов свойств
let product: { id: number; name: string; inStock: boolean } = {
    id: 1,
    name: "Ноутбук",
    inStock: true
};
 
// Массив чисел
let fibonacci: number[] = [1, 1, 2, 3, 5, 8, 13];
 
// Функциональный тип (сигнатура функции)
let logger: (message: string) => void;
logger = (message) => console.log(`LOG: ${message}`);

let empty: null = null;
let notDefined: undefined = undefined;

// При включенном strictNullChecks это вызовет ошибку
let userName: string = null; 
 
// Правильный способ
let userNameOrNull: string | null = null;

// Переменная может содержать только конкретную строку
let direction: "north" | "south" | "east" | "west";
direction = "north"; // Допустимо
direction = "northeast"; // Ошибка: Type '"northeast"' is not assignable
 
// Числовые литералы
let diceRoll: 1 | 2 | 3 | 4 | 5 | 6;
diceRoll = 3; // Допустимо
diceRoll = 7; // Ошибка

// С использованием обобщенного типа Array
let fruits: Array<string> = ["яблоко", "банан", "груша"];
 
// С использованием синтаксиса квадратных скобок
let vegetables: string[] = ["морковь", "капуста", "свекла"];

// Кортеж, где первый элемент — строка, а второй — число
let nameAndAge: [string, number] = ["Антон", 34];
 
// Деструктуризация кортежа
let [name, age] = nameAndAge;

// Функция, возвращающая кортеж
function getUserInfo(): [string, number, boolean] {
    // Возвращаем имя, возраст и статус активности
    return ["Мария", 28, true];
}
 
const [userName, userAge, isActive] = getUserInfo();

let userInput: unknown;
let userName: string;
 
userInput = "Иван";
// userName = userInput; // Ошибка: переменная типа unknown не может быть присвоена переменной типа string
 
// Необходима проверка типа перед использованием
if (typeof userInput === "string") {
    userName = userInput; // Теперь это допустимо
}

function logMessage(message: string): void {
    console.log(message);
    // Без оператора return или с пустым return
}
 
// Переменные типа void могут хранить только undefined или null (при выключенном strictNullChecks)
let unusable: void = undefined;

function throwError(message: string): never {
    throw new Error(message);
}
 
function infiniteLoop(): never {
    while (true) {
        // Что-то делаем бесконечно
    }
}

function assertNever(value: never): never {
    throw new Error(`Недопустимое значение: ${value}`);
}
 
type Shape = Circle | Square;
 
function getArea(shape: Shape) {
    if ('radius' in shape) {
        return Math.PI * shape.radius [B] 2;
    } else if ('sideLength' in shape) {
        return shape.sideLength [/B] 2;
    } else {
        // Если в будущем тип Shape расширится новыми вариантами,
        // TypeScript укажет на ошибку в этой строке
        return assertNever(shape);
    }
}

enum Direction {
    North,
    East,
    South,
    West
}
 
let currentDirection: Direction = Direction.North;
 
// По умолчанию значения начинаются с 0
console.log(Direction.North); // 0
console.log(Direction.East);  // 1
 
// Можно задать начальное значение
enum HttpStatus {
    OK = 200,
    NotFound = 404,
    InternalServerError = 500
}
 
function handleResponse(status: HttpStatus) {
    if (status === HttpStatus.OK) {
        console.log("Запрос выполнен успешно");
    }
}

enum Color {
    Red = "RED",
    Green = "GREEN",
    Blue = "BLUE"
}
 
let favoriteColor: Color = Color.Blue;
console.log(favoriteColor); // "BLUE"

let user: { id: number; name: string; email?: string } = {
    id: 1,
    name: "Анна"
    // email не обязателен благодаря модификатору "?"
};
 
// Функция, принимающая объект со свойствами x и y
function printPoint(point: { x: number; y: number }): void {
    console.log(`X: ${point.x}, Y: ${point.y}`);
}

interface User {
    id: number;
    name: string;
    email?: string;
    readonly createdAt: Date;
    updateProfile(newName: string): void;
}
 
let admin: User = {
    id: 1,
    name: "Администратор",
    createdAt: new Date(),
    updateProfile(newName) {
        this.name = newName;
    }
};
 
// Нельзя изменить свойство, помеченное как readonly
// admin.createdAt = new Date(); // Ошибка

let obj: object = { key: "value" };
// obj = 42; // Ошибка: Type 'number' is not assignable to type 'object'
 
// Однако доступ к свойствам ограничен
// console.log(obj.key); // Ошибка: Property 'key' does not exist on type 'object'

// Record<K, V> создаёт объект с ключами типа K и значениями типа V
let dictionary: Record<string, number> = {
    "one": 1,
    "two": 2,
    "three": 3
};
 
// Можно добавлять новые пары ключ-значение
dictionary["four"] = 4;

// Для использования bigint необходимо указать target ES2020 или выше в tsconfig.json
const bigNumber: bigint = 1234567890123456789012345678901234567890n;
const anotherBig: bigint = BigInt("9007199254740991");

const key1: symbol = Symbol("description");
const key2: symbol = Symbol("description");
 
console.log(key1 === key2); // false, символы всегда уникальны
 
const obj = {
    [key1]: "Значение, доступное через символьный ключ"
};
 
console.log(obj[key1]); // "Значение, доступное через символьный ключ"

// Предположим, что getElementById возвращает HTMLElement или null
const input = document.getElementById("username") as HTMLInputElement;
 
// Теперь TypeScript "знает", что input — это HTMLInputElement
console.log(input.value);
 
// Альтернативный синтаксис (менее распространен)
const input2 = <HTMLInputElement>document.getElementById("password");

const point = { x: 10, y: 20 };
type Point = typeof point; // { x: number; y: number; }
 
function greet(name: string, age: number) {
    return `Привет, ${name}! Тебе ${age} лет.`;
}
type GreetFunction = typeof greet; // (name: string, age: number) => string

// Переменная может содержать либо строку, либо число
let id: string | number;
id = "abc123"; // Корректно
id = 42;       // Тоже корректно
id = true;     // Ошибка: тип boolean не входит в union string | number

function formatId(id: string | number): string {
  if (typeof id === "string") {
    return id.toUpperCase();
  } else {
    return `ID-${id.toString().padStart(6, '0')}`;
  }
}

type Employee = {
  id: number;
  name: string;
};
 
type Manager = {
  employees: Employee[];
  departmentId: number;
};
 
// Тип, объединяющий свойства Employee и Manager
type ManagerWithDetails = Employee & Manager;
 
const director: ManagerWithDetails = {
  id: 1,
  name: "Анна Иванова",
  employees: [{id: 2, name: "Иван Петров"}],
  departmentId: 100
};

// Функция identity возвращает то же значение, что получила
function identity<T>(arg: T): T {
  return arg;
}
 
// Явное указание типа
const numResult = identity<number>(42);
// Вывод типа
const strResult = identity("hello"); // TypeScript выведет T как string

// Обобщённый интерфейс для контейнера
interface Box<T> {
  value: T;
}
 
// Использование с конкретным типом
const numberBox: Box<number> = { value: 42 };
const stringBox: Box<string> = { value: "hello" };

// T должен иметь свойство length
function getLength<T extends { length: number }>(arg: T): number {
  return arg.length;
}
 
getLength("string");     // Работает: у строк есть свойство length
getLength([1, 2, 3]);    // Работает: у массивов есть свойство length
getLength({ length: 5 }); // Работает: у объекта есть свойство length
// getLength(42);       // Ошибка: у чисел нет свойства length

interface User {
  id: number;
  name: string;
  email: string;
}
 
// Все свойства становятся необязательными
function updateUser(userId: number, updates: Partial<User>) {
  // Можно передать только нужные поля
}
 
updateUser(1, { name: "Новое имя" }); // Не требуется email

interface Config {
  host?: string;
  port?: number;
  secure?: boolean;
}
 
// Все свойства становятся обязательными
const fullConfig: Required<Config> = {
  host: "localhost",
  port: 8080,
  secure: true
};

const frozenUser: Readonly<User> = {
  id: 1,
  name: "Иван",
  email: "ivan@example.com"
};
 
// frozenUser.name = "Петр"; // Ошибка: нельзя изменить readonly свойство

// Только id и name из интерфейса User
type BasicUser = Pick<User, "id" | "name">;
 
const basicUser: BasicUser = {
  id: 1,
  name: "Иван"
  // email не нужен
};

// Все свойства User кроме email
type UserWithoutEmail = Omit<User, "email">;
 
const userNoEmail: UserWithoutEmail = {
  id: 1,
  name: "Иван"
  // email не разрешен
};

// Объект с числовыми ключами и строковыми значениями
const ages: Record<number, string> = {
  10: "десять",
  20: "двадцать",
  30: "тридцать"
};

// T extends U ? X : Y — если T является подтипом U, выбираем X, иначе Y
type IsString<T> = T extends string ? true : false;
 
// Примеры использования
type A = IsString<"hello">; // true
type B = IsString<42>;      // false

// Извлекаем тип возвращаемого значения функции
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
 
function fetchUser() {
  return { id: 1, name: "Анна" };
}
 
type User = ReturnType<typeof fetchUser>; // { id: number; name: string; }

// Делаем все свойства объекта необязательными
type Optional<T> = {
  [P in keyof T]?: T[P];
};
 
interface Person {
  name: string;
  age: number;
}
 
// Все свойства стали необязательными
const partialPerson: Optional<Person> = { name: "Иван" };

// Делаем все свойства доступными только для чтения и строковыми
type ReadonlyStringified<T> = {
  readonly [P in keyof T]: string;
};
 
const stringPerson: ReadonlyStringified<Person> = {
  name: "Иван",
  age: "30" // Теперь это строка
};
 
// stringPerson.name = "Петр"; // Ошибка: нельзя изменить readonly свойство

function processValue(value: string | number) {
  // В этом блоке TypeScript знает, что value — строка
  if (typeof value === "string") {
    return value.toUpperCase();
  }
  
  // А в этом блоке — число
  return value.toFixed(2);
}

interface Bird {
  fly(): void;
  layEggs(): void;
}
 
interface Fish {
  swim(): void;
  layEggs(): void;
}
 
function move(animal: Bird | Fish) {
  if ("fly" in animal) {
    // TypeScript знает, что здесь animal — это Bird
    animal.fly();
  } else {
    // А здесь — Fish
    animal.swim();
  }
}

class Car {
  drive() { console.log("Вррум!"); }
}
 
class Bicycle {
  ride() { console.log("Крутим педали!"); }
}
 
function useVehicle(vehicle: Car | Bicycle) {
  if (vehicle instanceof Car) {
    vehicle.drive();
  } else {
    vehicle.ride();
  }
}

interface Rectangle {
  kind: "rectangle";
  width: number;
  height: number;
}
 
interface Circle {
  kind: "circle";
  radius: number;
}
 
type Shape = Rectangle | Circle;
 
// Пользовательский защитник типа
function isRectangle(shape: Shape): shape is Rectangle {
  return shape.kind === "rectangle";
}
 
function calculateArea(shape: Shape): number {
  if (isRectangle(shape)) {
    // TypeScript знает, что shape — это Rectangle
    return shape.width * shape.height;
  } else {
    // А здесь shape — это Circle
    return Math.PI * shape.radius ** 2;
  }
}

interface Square {
  kind: "square";
  size: number;
}
 
interface Rectangle {
  kind: "rectangle";
  width: number;
  height: number;
}
 
interface Circle {
  kind: "circle";
  radius: number;
}
 
type Shape = Square | Rectangle | Circle;
 
function calculateArea(shape: Shape): number {
  switch (shape.kind) {
    case "square":
      return shape.size ** 2;
    case "rectangle":
      return shape.width * shape.height;
    case "circle":
      return Math.PI * shape.radius ** 2;
    default:
      // TypeScript проверит, что все варианты обработаны
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

interface Drawable {
  draw(): void;
  resize(width: number, height: number): void;
}
 
// Класс, реализующий интерфейс
class Circle implements Drawable {
  constructor(private radius: number) {}
  
  draw() {
    console.log(`Рисуем круг радиусом ${this.radius}`);
  }
  
  resize(width: number, height: number) {
    this.radius = Math.min(width, height) / 2;
  }
}

interface Person {
  name: string;
  age: number;
}
 
interface Employee extends Person {
  employeeId: string;
  department: string;
}
 
// Объект должен содержать все поля из обоих интерфейсов
const manager: Employee = {
  name: "Иван",
  age: 35,
  employeeId: "EMP123",
  department: "IT"
};

class Animal {
  // Модификаторы доступа: public, private, protected
  constructor(protected name: string) {}
  
  move(distance: number = 0): void {
    console.log(`${this.name} передвигается на ${distance}м.`);
  }
}
 
class Dog extends Animal {
  constructor(name: string, private breed: string) {
    super(name);
  }
  
  bark(): void {
    console.log("Гав-гав!");
  }
  
  // Переопределение метода родительского класса
  move(distance: number = 5): void {
    console.log(`${this.name} породы ${this.breed} бежит...`);
    super.move(distance);
  }
}
 
const dog = new Dog("Рекс", "Овчарка");
dog.bark();
dog.move(10);

abstract class Shape {
  constructor(protected color: string) {}
  
  // Абстрактный метод, должен быть реализован в подклассах
  abstract calculateArea(): number;
  
  // Конкретный метод с реализацией
  display(): void {
    console.log(`Фигура цвета ${this.color}`);
  }
}
 
class Rectangle extends Shape {
  constructor(
    color: string, 
    private width: number, 
    private height: number
  ) {
    super(color);
  }
  
  calculateArea(): number {
    return this.width * this.height;
  }
  
  // Дополнительный метод, специфичный для прямоугольника
  get diagonal(): number {
    return Math.sqrt(this.width [B] 2 + this.height [/B] 2);
  }
}

class BankAccount {
  // Публичное свойство, доступно везде
  public owner: string;
  
  // Приватное свойство, доступно только внутри класса
  private balance: number;
  
  // Защищенное свойство, доступно в классе и подклассах
  protected accountNumber: string;
  
  constructor(owner: string, initialBalance: number) {
    this.owner = owner;
    this.balance = initialBalance;
    this.accountNumber = `ACC${Math.floor(Math.random() * 10000)}`;
  }
  
  deposit(amount: number): void {
    this.balance += amount;
  }
  
  getBalance(): number {
    return this.balance;
  }
}
 
class SavingsAccount extends BankAccount {
  private interestRate: number;
  
  constructor(owner: string, initialBalance: number, interestRate: number) {
    super(owner, initialBalance);
    this.interestRate = interestRate;
  }
  
  addInterest(): void {
    // Можем использовать accountNumber (protected)
    console.log(`Начисляем проценты на счет ${this.accountNumber}`);
    // Но не можем напрямую обратиться к balance (private)
    // Используем публичный метод
    const currentBalance = this.getBalance();
    this.deposit(currentBalance * this.interestRate);
  }
}

class Person {
  #secretId: string;
  
  constructor(public name: string) {
    this.#secretId = `secret-${Math.random()}`;
  }
  
  getSecretId(): string {
    return this.#secretId;
  }
}
 
const person = new Person("Анна");
console.log(person.name);       // OK
// console.log(person.#secretId);  // Ошибка: приватное поле

namespace Geometry {
  export interface Point {
    x: number;
    y: number;
  }
  
  export class Line {
    constructor(public start: Point, public end: Point) {}
    
    length(): number {
      const dx = this.end.x - this.start.x;
      const dy = this.end.y - this.start.y;
      return Math.sqrt(dx * dx + dy * dy);
    }
  }
  
  // Вложенное пространство имен
  export namespace ThreeDimensional {
    export interface Point3D extends Point {
      z: number;
    }
  }
}
 
// Использование
const point1: Geometry.Point = { x: 0, y: 0 };
const point2: Geometry.Point = { x: 3, y: 4 };
const line = new Geometry.Line(point1, point2);
console.log(line.length()); // 5
 
// Использование вложенного пространства имен
const point3D: Geometry.ThreeDimensional.Point3D = { x: 1, y: 2, z: 3 };

// math.ts
export function add(a: number, b: number): number {
  return a + b;
}
 
export function subtract(a: number, b: number): number {
  return a - b;
}
 
export interface MathOperation {
  (a: number, b: number): number;
}

// app.ts
import { add, MathOperation } from './math';
// Импорт всего модуля
import * as Math from './math';
 
const sum = add(5, 3);
const difference = Math.subtract(10, 4);
 
// Использование импортированного интерфейса
const multiply: MathOperation = (a, b) => a * b;

interface Person {
  name: string;
  age: number;
  address: string;
}
 
// 'name' | 'age' | 'address'
type PersonKeys = keyof Person;
 
// Функция для безопасного получения свойства объекта по ключу
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
 
const john: Person = {
  name: "Иван",
  age: 30,
  address: "ул. Примерная, 123"
};
 
const johnName = getProperty(john, "name");  // строка
const johnAge = getProperty(john, "age");    // число
// const error = getProperty(john, "job");   // Ошибка: "job" не является ключом Person

interface Dictionary<T> {
  [key: string]: T;
}
 
const stringDict: Dictionary<string> = {
  "a": "apple",
  "b": "banana"
};
 
// Получаем тип элементов словаря: string
type DictValue = Dictionary<string>["a"];
 
// С ограниченным набором ключей
interface PersonWithCategories {
  name: string;
  age: number;
  categories: {
    primary: string;
    secondary: string;
  };
}
 
// Тип для категорий: { primary: string; secondary: string; }
type Categories = PersonWithCategories["categories"];
 
// Тип для первичной категории: string
type PrimaryCategory = PersonWithCategories["categories"]["primary"];

type Color = "red" | "green" | "blue";
type Quantity = "one" | "two" | "three";
 
// "one_red" | "one_green" | "one_blue" | "two_red" | ... и т.д.
type ColorQuantity = `${Quantity}_${Color}`;
 
// Преобразование ключей в camelCase
type CamelCase<S extends string> = S extends `${infer P}_${infer Q}`
  ? `${P}${Capitalize<Q>}`
  : S;
 
// Пример использования: "user_id" -> "userId"
type CamelCaseTest = CamelCase<"user_id">;
 
// Преобразование всех ключей объекта
type CamelCaseKeys<T> = {
  [K in keyof T as CamelCase<string & K>]: T[K]
};
 
interface ApiResponse {
  user_id: number;
  first_name: string;
  last_name: string;
}
 
// Результат: { userId: number; firstName: string; lastName: string; }
type NiceResponse = CamelCaseKeys<ApiResponse>;

// Рекурсивный тип для древовидной структуры
type TreeNode<T> = {
  value: T;
  children?: TreeNode<T>[];
};
 
// Использование
const tree: TreeNode<string> = {
  value: "root",
  children: [
    { value: "child1" },
    { 
      value: "child2",
      children: [
        { value: "grandchild1" },
        { value: "grandchild2" }
      ]
    }
  ]
};
 
// Рекурсивный тип для JSON-подобных данных
type JSONValue =
  | string
  | number
  | boolean
  | null
  | JSONValue[]
  | { [key: string]: JSONValue };
 
const data: JSONValue = {
  name: "Документ",
  created: true,
  value: 42,
  metadata: {
    author: "Иван",
    tags: ["важное", "документация"]
  }
};

// Включите "experimentalDecorators": true в tsconfig.json
 
// Декоратор класса
function Logger(target: Function) {
  console.log(`Создан класс: ${target.name}`);
}
 
// Декоратор свойства
function Property(target: any, propertyKey: string) {
  console.log(`Определено свойство: ${propertyKey}`);
}
 
// Декоратор метода
function Method(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const original = descriptor.value;
  descriptor.value = function(...args: any[]) {
    console.log(`Вызов ${propertyKey} с аргументами: ${JSON.stringify(args)}`);
    return original.apply(this, args);
  };
}
 
@Logger
class Example {
  @Property
  name: string;
 
  constructor(name: string) {
    this.name = name;
  }
 
  @Method
  greet(message: string): string {
    return `${this.name} говорит: ${message}`;
  }
}
 
const example = new Example("Анна");
console.log(example.greet("Привет!"));
// Вывод:
// Создан класс: Example
// Определено свойство: name
// Вызов greet с аргументами: ["Привет!"]
// Анна говорит: Привет!

// Базовый класс
class Base {
  isBase = true;
  baseMethod() { return "base method"; }
}
 
// Миксин, добавляющий функциональность таймштампов
type Constructor<T = {}> = new (...args: any[]) => T;
 
function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    timestamp = Date.now();
    
    getTimestamp() {
      return new Date(this.timestamp);
    }
  };
}
 
// Миксин для идентификации
function Identified<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    id = Math.random().toString(36).substring(2, 9);
    
    getId() {
      return this.id;
    }
  };
}
 
// Объединение миксинов
const TimestampedBase = Timestamped(Base);
const IdentifiedTimestampedBase = Identified(TimestampedBase);
 
// Использование комбинированного класса
const instance = new IdentifiedTimestampedBase();
console.log(instance.isBase);       // true
console.log(instance.baseMethod()); // "base method"
console.log(instance.getTimestamp()); // текущая дата
console.log(instance.getId());      // случайный ID

// Анти-паттерн
function processData(data: any) {
  return data.someProperty.method(); // Может взорваться в рантайме
}

function processData(data: unknown) {
  if (typeof data === 'object' && data !== null && 'someProperty' in data) {
    const item = data as { someProperty: { method: () => void } };
    return item.someProperty.method();
  }
  throw new Error('Некорректный формат данных');
}

// Анти-паттерн
const userData = JSON.parse(response) as UserData; // Опасно!

function isUserData(data: unknown): data is UserData {
  return (
    typeof data === 'object' &&
    data !== null &&
    'id' in data &&
    'name' in data &&
    typeof (data as any).id === 'number' &&
    typeof (data as any).name === 'string'
  );
}
 
const responseData = JSON.parse(response);
if (isUserData(responseData)) {
  const userData: UserData = responseData;
  // Безопасно использовать userData
} else {
  throw new Error('Некорректный формат пользовательских данных');
}

// Анти-паттерн
function getFirstItem(items: string[]) {
  return items[0].toUpperCase(); // Может вызвать ошибку, если массив пуст
}

function getFirstItem(items: string[]): string | undefined {
  const item = items[0];
  return item ? item.toUpperCase() : undefined;
}
 
// Или с оператором опциональной последовательности
function getFirstItem(items: string[]): string | undefined {
  return items[0]?.toUpperCase();
}

// types.ts
export interface User {
  id: number;
  name: string;
  email: string;
}
 
export type UserRole = 'admin' | 'moderator' | 'user';
 
export interface AuthResponse {
  user: User;
  token: string;
  role: UserRole;
}

// Анти-паттерн
interface User {
  id: number;
  name: string;
  email: string;
}
 
interface UserWithRole { // Дублирование полей
  id: number;
  name: string;
  email: string;
  role: string;
}
 
// Правильный подход
interface User {
  id: number;
  name: string;
  email: string;
}
 
interface UserWithRole extends User {
  role: string;
}

interface ApiResponse<T> {
  data: T;
  status: number;
  message: string;
  timestamp: string;
}
 
// Получение только полезных данных
type ResponseData<T> = ApiResponse<T>['data'];
 
// Частичные обновления
interface User {
  id: number;
  name: string;
  email: string;
  settings: {
    theme: string;
    notifications: boolean;
  };
}
 
// Тип для обновления только настроек
type UserSettingsUpdate = Partial<Pick<User, 'settings'>>;
 
// Использование
function updateUserSettings(userId: number, settings: UserSettingsUpdate) {
  // Реализация обновления
}

// До миграции (js)
function calculateTotal(items) {
  return items.reduce((total, item) => total + item.price * item.quantity, 0);
}
 
// Начальная миграция (ts)
function calculateTotal(items: any[]): number {
  return items.reduce((total, item) => total + item.price * item.quantity, 0);
}
 
// Полная типизация
interface CartItem {
  id: string;
  price: number;
  quantity: number;
}
 
function calculateTotal(items: CartItem[]): number {
  return items.reduce((total, item) => total + item.price * item.quantity, 0);
}

// Вместо одного большого файла
// components.ts
 
// Разделите на несколько маленьких
// components/Button.ts
// components/Input.ts
// components/Card.ts
// components/index.ts (реэкспорт)

// Медленный тип с глубокой вложенностью
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? T[P] extends Function
      ? T[P]
      : DeepReadonly<T[P]>
    : T[P]
};
 
// Более эффективная альтернатива для больших объектов
interface ReadonlyUser {
  readonly id: number;
  readonly name: string;
  readonly settings: ReadonlySettings;
}

// Возвращает Promise с конкретным типом результата
async function fetchUserData(id: number): Promise<UserData> {
  const response = await fetch(`/api/users/${id}`);
  if (!response.ok) {
    throw new Error(`HTTP error: ${response.status}`);
  }
  const data = await response.json();
  return data as UserData;
}
 
// Использование
async function displayUser(id: number): Promise<void> {
  try {
    const user = await fetchUserData(id);
    console.log(`Загружен пользователь: ${user.name}`);
  } catch (error) {
    console.error("Ошибка загрузки:", error);
  }
}

class NetworkError extends Error {
  constructor(public statusCode: number, message: string) {
    super(message);
    this.name = "NetworkError";
  }
}
 
class ValidationError extends Error {
  constructor(public fields: string[], message: string) {
    super(message);
    this.name = "ValidationError";
  }
}
 
async function fetchData(): Promise<UserData> {
  try {
    // реализация
  } catch (error: unknown) {
    if (error instanceof NetworkError) {
      // Обработка сетевой ошибки
      if (error.statusCode === 404) {
        return getDefaultUser(); // Возвращаем значение по умолчанию
      }
    }
    if (error instanceof ValidationError) {
      // Обработка ошибки валидации
      console.error("Некорректные поля:", error.fields);
    }
    throw error; // Пробрасываем остальные ошибки
  }
}

interface User {
  id: number;
  name: string;
}
 
interface Post {
  id: number;
  title: string;
  content: string;
}
 
// Получение связанных данных
async function getUserWithPosts(userId: number): Promise<{user: User; posts: Post[]}> {
  const [user, posts] = await Promise.all([
    fetchUser(userId),
    fetchUserPosts(userId)
  ]);
  
  return { user, posts };
}

// types/untyped-library/index.d.ts
declare module 'untyped-library' {
  export function doSomething(input: string): number;
  
  export interface Options {
    timeout?: number;
    retries?: number;
  }
  
  export default function main(options?: Options): void;
}

// Расширение существующего модуля
import { Express } from 'express';
 
// Добавление пользовательских свойств
declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string;
        role: string;
      };
    }
  }
}

interface ButtonProps {
  text: string;
  onClick: () => void;
  variant?: 'primary' | 'secondary';
  disabled?: boolean;
}
 
// Используем React.FC с дженериком (хотя современный React склоняется к явному указанию типа возврата)
const Button: React.FC<ButtonProps> = ({ text, onClick, variant = 'primary', disabled = false }) => {
  return (
    <button
      className={`btn btn-${variant}`}
      onClick={onClick}
      disabled={disabled}
    >
      {text}
    </button>
  );
};
 
// Более современный подход
function Button({ text, onClick, variant = 'primary', disabled = false }: ButtonProps): JSX.Element {
  // Реализация
}

// Определение типов действий
type ActionTypes = 
  | { type: 'ADD_TODO'; payload: { text: string } }
  | { type: 'TOGGLE_TODO'; payload: { id: number } }
  | { type: 'REMOVE_TODO'; payload: { id: number } };
 
// Определение типа состояния
interface Todo {
  id: number;
  text: string;
  completed: boolean;
}
 
interface TodoState {
  todos: Todo[];
  loading: boolean;
}
 
// Типизированный редьюсер
function todoReducer(state: TodoState, action: ActionTypes): TodoState {
  switch (action.type) {
    case 'ADD_TODO':
      return {
        ...state,
        todos: [...state.todos, { id: Date.now(), text: action.payload.text, completed: false }]
      };
    // Другие случаи
    default:
      return state;
  }
}

// packages/common/src/types/index.ts
export interface User {
 id: string;
 name: string;
 email: string;
}
 
// packages/api/src/users/service.ts
import { User } from '@project/common';
 
export async function getUserById(id: string): Promise<User> {
 // Реализация
}
 
// packages/frontend/src/components/UserProfile.tsx
import { User } from '@project/common';
import { getUserById } from '@project/api';
 
interface Props {
 userId: string;
}
 
export function UserProfile({ userId }: Props) {
 const [user, setUser] = useState<User | null>(null);
 
 useEffect(() => {
   async function fetchUser() {
     try {
       const userData = await getUserById(userId);
       setUser(userData);
     } catch (error) {
       console.error('Failed to fetch user:', error);
     }
   }
   
   fetchUser();
 }, [userId]);
 
 // Отображение профиля
}

src/
├── types/
│   ├── index.ts     # Реэкспорт всех типов
│   ├── user.ts      # Типы, связанные с пользователями
│   ├── product.ts   # Типы, связанные с продуктами
│   └── ...

src/
├── features/
│   ├── user/
│   │   ├── types.ts  # Типы пользователя
│   │   ├── api.ts
│   │   └── components/
│   └── product/
│       ├── types.ts  # Типы продукта
│       └── ...

src/
├── types/           # Общие типы
│   ├── common.ts
│   └── api.ts
├── features/
│   ├── user/
│   │   ├── types.ts  # Специфичные типы пользователя
│   │   └── ...

import type { components } from '../types/api';
 
type User = components['schemas']['User'];
type CreateUserRequest = components['schemas']['CreateUserRequest'];
 
async function createUser(data: CreateUserRequest): Promise<User> {
 const response = await fetch('/api/users', {
   method: 'POST',
   headers: { 'Content-Type': 'application/json' },
   body: JSON.stringify(data)
 });
 
 if (!response.ok) {
   throw new Error(`API error: ${response.status}`);
 }
 
 return await response.json() as User;
}

// packages/shared-types/index.ts
export interface User {
 id: string;
 email: string;
 name: string;
 role: 'admin' | 'user';
 createdAt: string; // ISO date string
}
 
export interface CreateUserDto {
 email: string;
 name: string;
 password: string;
}
 
// Типы ответов API
export interface ApiResponse<T> {
 data: T;
 status: 'success' | 'error';
 message?: string;
}

// Было
interface User {
 id: string;
 name: string;
}
 
// Стало (обратно совместимо)
interface User {
 id: string;
 name: string;
 email?: string; // Новое опциональное поле
}

// Было
function fetchUsers(query: string): Promise<User[]>;
 
// Стало (обратно совместимо)
function fetchUsers(query: string): Promise<User[]>;
function fetchUsers(query: string, options: FetchOptions): Promise<User[]>;
function fetchUsers(query: string, options?: FetchOptions): Promise<User[]> {
 // Реализация
}

// Было
type UserRole = 'admin' | 'user';
 
// Стало (обратно совместимо)
type LegacyUserRole = 'admin' | 'user';
type NewUserRole = 'admin' | 'user' | 'moderator';
type UserRole = LegacyUserRole | NewUserRole;

/**
* @deprecated Use `NewUserInterface` instead. Will be removed in version 3.0.0.
*/
export interface User {
 // ...
}
 
export interface NewUserInterface {
 // ...
}

// tests/types.test.ts
import { expectType } from 'tsd';
import { User, createUser } from '../src/user';
 
// Проверка, что функция возвращает правильный тип
expectType<Promise<User>>(createUser('John', 'john@example.com'));
 
// Проверка, что тип содержит ожидаемые свойства
type UserKeys = keyof User;
expectType<'id' | 'name' | 'email'>('' as unknown as UserKeys);
 
// Проверка, что тип не допускает неверные значения
// @ts-expect-error
const invalidUser: User = { name: 'John' }; // Отсутствует обязательное поле id

// Автоматическая генерация типов из моделей базы данных
import { Model, DataTypes } from 'sequelize';
import { generateTypes } from 'sequelize-typescript-generator';
 
class UserModel extends Model {
 static init(sequelize) {
   super.init({
     id: {
       type: DataTypes.UUID,
       primaryKey: true
     },
     name: DataTypes.STRING,
     email: {
       type: DataTypes.STRING,
       unique: true
     }
   }, { sequelize });
 }
}
 
// Генерация типов из модели
generateTypes([UserModel], 'src/types/generated');

// Типизированный паттерн Наблюдатель (Observer)
interface Observer<T> {
 update(data: T): void;
}
 
class Subject<T> {
 private observers: Observer<T>[] = [];
 
 attach(observer: Observer<T>): void {
   if (!this.observers.includes(observer)) {
     this.observers.push(observer);
   }
 }
 
 detach(observer: Observer<T>): void {
   const index = this.observers.indexOf(observer);
   if (index !== -1) {
     this.observers.splice(index, 1);
   }
 }
 
 notify(data: T): void {
   for (const observer of this.observers) {
     observer.update(data);
   }
 }
}
 
// Использование
interface UserUpdateEvent {
 userId: string;
 field: 'name' | 'email';
 newValue: string;
}
 
class UserService extends Subject<UserUpdateEvent> {
 updateUserField(userId: string, field: 'name' | 'email', value: string): void {
   // Логика обновления
   
   // Уведомление наблюдателей
   this.notify({ userId, field, newValue: value });
 }
}
 
class NotificationService implements Observer<UserUpdateEvent> {
 update(data: UserUpdateEvent): void {
   console.log(`User ${data.userId} changed ${data.field} to ${data.newValue}`);
 }
}
 
// Настройка
const userService = new UserService();
const notificationService = new NotificationService();
userService.attach(notificationService);
 
// Использование
userService.updateUserField('user-123', 'name', 'John Doe');