Какие знаешь парадигмы в TypeScript?

Парадигмы программирования в TypeScript

TypeScript, как надмножество JavaScript, поддерживает мультипарадигменность, позволяя разработчикам комбинировать разные подходы в зависимости от задач проекта. Вот ключевые парадигмы, которые я активно применяю на практике.

1. Объектно-ориентированное программирование (ООП)

TypeScript предлагает полноценную поддержку ООП с классами, интерфейсами и модификаторами доступа.

// Пример использования ООП
interface IAnimal {
  name: string;
  makeSound(): void;
}

abstract class Animal implements IAnimal {
  constructor(public name: string) {}
  
  abstract makeSound(): void;
  
  move(distance: number = 0): void {
    console.log(`${this.name} moved ${distance}m`);
  }
}

class Dog extends Animal {
  makeSound(): void {
    console.log(`${this.name} barks: Woof!`);
  }
}

const dog = new Dog("Rex");
dog.makeSound(); // Rex barks: Woof!
dog.move(10);    // Rex moved 10m

Ключевые возможности::

• Наследование через extends
• Инкапсуляция с модификаторами private, protected, public
• Полиморфизм через переопределение методов
• Абстракция с помощью abstract классов и интерфейсов

2. Функциональное программирование (ФП)

TypeScript отлично подходит для ФП благодаря поддержке функций первого класса и типам высшего порядка.

// Функциональный подход
type MathOperation = (a: number, b: number) => number;

const multiply: MathOperation = (a, b) => a * b;
const add: MathOperation = (a, b) => a + b;

// Функция высшего порядка
const createMultiplier = (factor: number): MathOperation => 
  (value) => value * factor;

const double = createMultiplier(2);
console.log(double(5)); // 10

// Чистые функции и иммутабельность
const immutableUpdate = <T>(arr: T[], item: T): T[] => [...arr, item];

Принципы ФП в TypeScript::

• Чистые функции без side effects
• Иммутабельность данных
• Функции высшего порядка
• Композиция функций
• Рекурсия вместо циклов

3. Процедурное программирование

Хотя менее популярно в современном TypeScript, процедурный подход всё ещё используется:

// Процедурный стиль
function calculateTotal(prices: number[]): number {
  let total = 0;
  
  for (let i = 0; i < prices.length; i++) {
    total += prices[i];
  }
  
  return total;
}

function applyDiscount(total: number, discount: number): number {
  return total - (total * discount / 100);
}

4. Реактивное программирование

Особенно актуально с библиотеками вроде RxJS:

import { fromEvent, map, filter } from 'rxjs';

// Реактивная обработка событий
const button = document.querySelector('button');
const clicks$ = fromEvent(button, 'click');

clicks$
  .pipe(
    filter(event => event.target !== null),
    map(event => ({ x: event.clientX, y: event.clientY }))
  )
  .subscribe(coords => {
    console.log(`Clicked at: ${coords.x}, ${coords.y}`);
  });

5. Декларативное программирование

TypeScript способствует декларативному стилю через современные API:

// Декларативный подход
const users = [
  { id: 1, name: "Alice", active: true },
  { id: 2, name: "Bob", active: false }
];

// Вместо императивных циклов
const activeUsers = users
  .filter(user => user.active)
  .map(user => user.name);

6. Обобщённое программирование (Generics)

TypeScript мощно реализует generic-программирование:

// Генералы для создания переиспользуемых компонентов
interface Repository<T> {
  getById(id: string): T | undefined;
  save(entity: T): void;
  getAll(): T[];
}

class UserRepository implements Repository<User> {
  private users: Map<string, User> = new Map();
  
  getById(id: string): User | undefined {
    return this.users.get(id);
  }
  
  save(user: User): void {
    this.users.set(user.id, user);
  }
  
  getAll(): User[] {
    return Array.from(this.users.values());
  }
}

Практическое комбинирование парадигм

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

// Комбинация ООП и ФП
class ShoppingCart {
  private items: CartItem[] = [];
  
  // ООП: инкапсуляция состояния
  addItem(item: CartItem): void {
    this.items = [...this.items, item]; // ФП: иммутабельное обновление
  }
  
  // ФП: чистая функция для вычислений
  calculateTotal(): number {
    return this.items.reduce(
      (total, item) => total + item.price * item.quantity, 
      0
    );
  }
}

Преимущества мультипарадигменности TypeScript:

• Гибкость выбора подхода под конкретную задачу
• Масштабируемость через ООП для сложных систем
• Предсказуемость через ФП для бизнес-логики
• Безопасность типов для раннего выявления ошибок
• Переиспользуемость кода через generics

На практике я выбираю парадигму исходя из:

1. Сложности доменной логики (ООП для сложных предметных областей)
2. Требований к предсказуемости (ФП для критической бизнес-логики)
3. Производительности (процедурный стиль для оптимизированных алгоритмов)
4. Реактивности UI (реактивное программирование для событийных систем)

TypeScript не навязывает конкретную парадигму, а предоставляет инструменты для каждой, что делает его исключительно мощным языком для enterprise-разработки.