Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura

Zasady SOLID w JavaScript/TypeScript

23 min czytania ·
W tej lekcji7

Witaj z powrotem w Parku Jurajskim! Wyobraź sobie centrum dowodzenia, gdzie jedna klasa steruje ogrodzeniami, sprzedaje bilety i wysyła maile. Poprawka w kasie może wtedy wyłączyć prąd na wybiegu T-Rexa. Lekarstwem jest SOLID: akronim pięciu zasad projektowania obiektowego, które spopularyzował Robert C. Martin. Choć powstały dla języków obiektowych, świetnie sprawdzają się w JavaScript i TypeScript.

S - Single Responsibility Principle (Zasada jednej odpowiedzialności)

Każda klasa lub moduł powinien mieć tylko jeden powód do zmiany, czyli jedną odpowiedzialność. Laboratorium DNA nie sprzedaje biletów, a kasa nie klonuje dinozaurów.

Złe podejście - naruszenie SRP

Oto pracownik od wszystkiego. Ile powodów do zmiany ma UserManager?

// Klasa UserManager robi za dużo rzeczy
class UserManager {
  constructor() {
    this.users = [];
  }

  // Zarządzanie użytkownikami
  addUser(userData) {
    this.users.push(userData);
  }

  removeUser(userId) {
    this.users = this.users.filter(user => user.id !== userId);
  }

  // Walidacja - inna odpowiedzialność
  validateEmail(email) {
    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
  }

  validatePassword(password) {
    return password.length >= 8 && /[A-Z]/.test(password);
  }

  // Logowanie - kolejna odpowiedzialność
  logUserAction(action, userId) {
    console.log(`[${new Date().toISOString()}] User ${userId}: ${action}`);
  }

  // Wysyłanie emaili - jeszcze inna odpowiedzialność
  sendWelcomeEmail(userEmail) {
    console.log(`Sending welcome email to ${userEmail}`);
  }

  // Formatowanie danych - kolejna odpowiedzialność
  formatUserData(user) {
    return `${user.firstName} ${user.lastName} (${user.email})`;
  }
}

Wychodzi pięć: przechowywanie, walidacja, logowanie, maile i formatowanie. Zmiana formatu logów wymusza edycję klasy, która pilnuje też haseł.

Dobre podejście - zgodne z SRP

Teraz każda odpowiedzialność dostaje własną klasę, a UserService je koordynuje:

// Każda klasa ma jedną odpowiedzialność

// Zarządzanie użytkownikami
interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
  password: string;
}

class UserRepository {
  private users: User[] = [];

  add(user: User): void {
    this.users.push(user);
  }

  remove(userId: string): boolean {
    const initialLength = this.users.length;
    this.users = this.users.filter(user => user.id !== userId);
    return this.users.length < initialLength;
  }

  findById(userId: string): User | null {
    return this.users.find(user => user.id === userId) || null;
  }

  findByEmail(email: string): User | null {
    return this.users.find(user => user.email === email) || null;
  }

  getAll(): User[] {
    return [...this.users];
  }
}

// Walidacja
class UserValidator {
  validateEmail(email: string): boolean {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
  }

  validatePassword(password: string): boolean {
    return password.length >= 8 &&
           /[A-Z]/.test(password) &&
           /[a-z]/.test(password) &&
           /[0-9]/.test(password);
  }

  validateUser(userData: Partial<User>): string[] {
    const errors: string[] = [];

    if (!userData.firstName || userData.firstName.length < 2) {
      errors.push('Imię musi mieć co najmniej 2 znaki');
    }

    if (!userData.lastName || userData.lastName.length < 2) {
      errors.push('Nazwisko musi mieć co najmniej 2 znaki');
    }

    if (!userData.email || !this.validateEmail(userData.email)) {
      errors.push('Nieprawidłowy format email');
    }

    if (!userData.password || !this.validatePassword(userData.password)) {
      errors.push('Hasło musi mieć co najmniej 8 znaków, wielką literę, małą literę i cyfrę');
    }

    return errors;
  }
}

// Logowanie
class UserLogger {
  private logs: string[] = [];

  logAction(action: string, userId: string): void {
    const logEntry = `[${new Date().toISOString()}] User ${userId}: ${action}`;
    this.logs.push(logEntry);
    console.log(logEntry);
  }

  getLogs(): string[] {
    return [...this.logs];
  }

  clearLogs(): void {
    this.logs = [];
  }
}

// Wysyłanie emaili
class EmailService {
  sendWelcomeEmail(userEmail: string, userName: string): Promise<boolean> {
    // Symulacja wysyłania emaila
    console.log(`Wysyłanie maila powitalnego do ${userEmail}`);
    return new Promise(resolve => {
      setTimeout(() => {
        console.log(`Mail powitalny wysłany do ${userName}`);
        resolve(true);
      }, 1000);
    });
  }

  sendPasswordResetEmail(userEmail: string): Promise<boolean> {
    console.log(`Wysyłanie maila z resetem hasła do ${userEmail}`);
    return Promise.resolve(true);
  }
}

// Formatowanie danych
class UserFormatter {
  formatFullName(user: User): string {
    return `${user.firstName} ${user.lastName}`;
  }

  formatUserDisplay(user: User): string {
    return `${this.formatFullName(user)} (${user.email})`;
  }

  formatUserSummary(user: User): object {
    return {
      id: user.id,
      fullName: this.formatFullName(user),
      email: user.email
    };
  }
}

// Service layer - koordynuje działanie różnych komponentów
class UserService {
  constructor(
    private userRepository: UserRepository,
    private userValidator: UserValidator,
    private userLogger: UserLogger,
    private emailService: EmailService,
    private userFormatter: UserFormatter
  ) {}

  async createUser(userData: Omit<User, 'id'>): Promise<User | null> {
    // Walidacja
    const validationErrors = this.userValidator.validateUser(userData);
    if (validationErrors.length > 0) {
      throw new Error(`Błędy walidacji: ${validationErrors.join(', ')}`);
    }

    // Sprawdzenie czy email nie jest zajęty
    if (this.userRepository.findByEmail(userData.email)) {
      throw new Error('Użytkownik z tym emailem już istnieje');
    }

    // Tworzenie użytkownika
    const user: User = {
      id: 'user_' + Math.random().toString(36).slice(2, 11),
      ...userData
    };

    this.userRepository.add(user);

    // Logowanie
    this.userLogger.logAction('USER_CREATED', user.id);

    // Wysyłanie maila powitalnego
    await this.emailService.sendWelcomeEmail(
      user.email,
      this.userFormatter.formatFullName(user)
    );

    return user;
  }

  deleteUser(userId: string): boolean {
    const user = this.userRepository.findById(userId);
    if (!user) {
      return false;
    }

    const deleted = this.userRepository.remove(userId);
    if (deleted) {
      this.userLogger.logAction('USER_DELETED', userId);
    }

    return deleted;
  }
}

// Użycie
const userRepository = new UserRepository();
const userValidator = new UserValidator();
const userLogger = new UserLogger();
const emailService = new EmailService();
const userFormatter = new UserFormatter();

const userService = new UserService(
  userRepository,
  userValidator,
  userLogger,
  emailService,
  userFormatter
);

// Test
userService.createUser({
  firstName: 'Jan',
  lastName: 'Kowalski',
  email: 'jan@example.com',
  password: 'SecurePass123'
}).then(user => {
  if (user) {
    console.log('Utworzono użytkownika:', userFormatter.formatUserDisplay(user));
  }
});

Zachowanie aplikacji się nie zmieniło, ale każdą część testujesz i wymieniasz osobno. Pomocników UserService dostaje w konstruktorze, co rozwinie litera D.

O - Open/Closed Principle (Zasada otwarte/zamknięte)

Klasy powinny być otwarte na rozszerzenie, ale zamknięte na modyfikację. Nowy gatunek oznacza nowy wybieg, a nie burzenie działających ogrodzeń.

Przykład z systemem płatności

Najpierw problem: ta funkcja wymaga edycji przy każdej nowej metodzie płatności.

// Naruszenie OCP - każdy nowy typ płatności to zmiana tej funkcji
function processPayment(type: string, amount: number): void {
  if (type === 'credit-card') {
    console.log(`Karta: ${amount} PLN`);
  } else if (type === 'paypal') {
    console.log(`PayPal: ${amount} PLN`);
  }
  // kryptowaluty? Kolejny else if w przetestowanym już kodzie
}

Wersja zgodna z OCP opiera się na interfejsie PaymentProcessor, a PaymentService trzyma procesory w mapie:

// Dobre podejście - zgodne z OCP

interface PaymentProcessor {
  processPayment(amount: number, details: any): Promise<PaymentResult>;
  validatePayment(details: any): boolean;
}

interface PaymentResult {
  success: boolean;
  transactionId?: string;
  error?: string;
}

// Podstawowa implementacja dla kart kredytowych
class CreditCardProcessor implements PaymentProcessor {
  async processPayment(amount: number, details: CreditCardDetails): Promise<PaymentResult> {
    if (!this.validatePayment(details)) {
      return { success: false, error: 'Nieprawidłowe dane karty' };
    }

    // Symulacja przetwarzania płatności kartą
    console.log(`Przetwarzanie płatności kartą: ${amount} PLN`);

    return {
      success: true,
      transactionId: 'cc_' + Math.random().toString(36).slice(2, 11)
    };
  }

  validatePayment(details: CreditCardDetails): boolean {
    return !!(details.cardNumber &&
             details.expiryDate &&
             details.cvv &&
             details.cardNumber.length === 16);
  }
}

interface CreditCardDetails {
  cardNumber: string;
  expiryDate: string;
  cvv: string;
  holderName: string;
}

// Rozszerzenie - nowy procesor bez modyfikacji istniejącego kodu
class PayPalProcessor implements PaymentProcessor {
  async processPayment(amount: number, details: PayPalDetails): Promise<PaymentResult> {
    if (!this.validatePayment(details)) {
      return { success: false, error: 'Nieprawidłowe dane PayPal' };
    }

    console.log(`Przetwarzanie płatności PayPal: ${amount} PLN`);

    return {
      success: true,
      transactionId: 'pp_' + Math.random().toString(36).slice(2, 11)
    };
  }

  validatePayment(details: PayPalDetails): boolean {
    return !!(details.email && details.password);
  }
}

interface PayPalDetails {
  email: string;
  password: string;
}

// Kolejne rozszerzenie
class BankTransferProcessor implements PaymentProcessor {
  async processPayment(amount: number, details: BankTransferDetails): Promise<PaymentResult> {
    if (!this.validatePayment(details)) {
      return { success: false, error: 'Nieprawidłowe dane przelewu' };
    }

    console.log(`Przetwarzanie przelewu bankowego: ${amount} PLN`);

    return {
      success: true,
      transactionId: 'bt_' + Math.random().toString(36).slice(2, 11)
    };
  }

  validatePayment(details: BankTransferDetails): boolean {
    return !!(details.accountNumber &&
             details.bankCode &&
             details.accountNumber.length >= 20);
  }
}

interface BankTransferDetails {
  accountNumber: string;
  bankCode: string;
  recipientName: string;
}

// Nowy procesor dla kryptowalut - bez modyfikacji istniejącego kodu
class CryptocurrencyProcessor implements PaymentProcessor {
  async processPayment(amount: number, details: CryptoDetails): Promise<PaymentResult> {
    if (!this.validatePayment(details)) {
      return { success: false, error: 'Nieprawidłowy adres portfela' };
    }

    console.log(`Przetwarzanie płatności ${details.currency}: ${amount} PLN`);

    return {
      success: true,
      transactionId: 'crypto_' + Math.random().toString(36).slice(2, 11)
    };
  }

  validatePayment(details: CryptoDetails): boolean {
    return !!(details.walletAddress &&
             details.currency &&
             details.walletAddress.length >= 26);
  }
}

interface CryptoDetails {
  walletAddress: string;
  currency: 'BTC' | 'ETH' | 'LTC';
}

// Kontekst używający procesorów - nie musi być modyfikowany
class PaymentService {
  private processors = new Map<string, PaymentProcessor>();

  registerProcessor(type: string, processor: PaymentProcessor): void {
    this.processors.set(type, processor);
  }

  async processPayment(type: string, amount: number, details: any): Promise<PaymentResult> {
    const processor = this.processors.get(type);

    if (!processor) {
      return { success: false, error: `Nieobsługiwany typ płatności: ${type}` };
    }

    return processor.processPayment(amount, details);
  }

  getSupportedPaymentTypes(): string[] {
    return Array.from(this.processors.keys());
  }
}

// Użycie - łatwe dodawanie nowych typów płatności
const paymentService = new PaymentService();

paymentService.registerProcessor('credit-card', new CreditCardProcessor());
paymentService.registerProcessor('paypal', new PayPalProcessor());
paymentService.registerProcessor('bank-transfer', new BankTransferProcessor());
paymentService.registerProcessor('crypto', new CryptocurrencyProcessor());

// Testowanie różnych typów płatności
async function testPayments() {
  // Płatność kartą
  const creditCardResult = await paymentService.processPayment('credit-card', 100, {
    cardNumber: '1234567890123456',
    expiryDate: '12/25',
    cvv: '123',
    holderName: 'Jan Kowalski'
  });

  // Płatność PayPal
  const paypalResult = await paymentService.processPayment('paypal', 50, {
    email: 'user@example.com',
    password: 'password123'
  });

  // Płatność kryptowalutą
  const cryptoResult = await paymentService.processPayment('crypto', 200, {
    walletAddress: '1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa',
    currency: 'BTC'
  });

  console.log('Wyniki płatności:', {
    creditCard: creditCardResult,
    paypal: paypalResult,
    crypto: cryptoResult
  });
}

testPayments();

Kryptowaluty nie zmieniły ani linijki w PaymentService, wystarczyło dopisać klasę i wywołać registerProcessor.

L - Liskov Substitution Principle (Zasada podstawienia Liskov)

Obiekty klas pochodnych powinny móc zastąpić obiekty klasy bazowej bez wpływu na poprawność programu. Zasadę sformułowała Barbara Liskov, a przykład dotyczy ptaków, żyjących potomków dinozaurów.

Przykład z ptakami - naruszenie LSP

Klasa Bird obiecuje, że każdy ptak lata. Co się stanie, gdy dołączy pingwin?

// Naruszenie LSP
abstract class Bird {
  abstract fly(): void;
  abstract makeSound(): void;
}

class Sparrow extends Bird {
  fly(): void {
    console.log('Wróbel leci!');
  }

  makeSound(): void {
    console.log('Ćwir ćwir!');
  }
}

class Eagle extends Bird {
  fly(): void {
    console.log('Orzeł szybuje!');
  }

  makeSound(): void {
    console.log('Krra!');
  }
}

// Problem: pingwin nie potrafi latać!
class Penguin extends Bird {
  fly(): void {
    throw new Error('Pingwiny nie potrafią latać!'); // Naruszenie LSP
  }

  makeSound(): void {
    console.log('Kwa kwa!');
  }
}

// Funkcja oczekująca, że każdy ptak potrafi latać
function makeBirdFly(bird: Bird): void {
  bird.fly(); // Może rzucić błąd dla pingwina!
}

TypeScript milczy, ale makeBirdFly(new Penguin()) rzuci wyjątek w trakcie działania. Podklasa złamała obietnicę klasy bazowej.

Poprawione podejście zgodne z LSP

Umiejętności trafiają do osobnych interfejsów Flyable, Swimmable i Walkable, a klasa bazowa obiecuje tylko to, co potrafi każdy ptak:

// Zgodne z LSP - lepsze modelowanie hierarchii

interface Animal {
  makeSound(): void;
  move(): void;
}

interface Flyable {
  fly(): void;
}

interface Swimmable {
  swim(): void;
}

interface Walkable {
  walk(): void;
}

// Klasa bazowa dla ptaków
abstract class Bird implements Animal {
  abstract makeSound(): void;
  abstract move(): void;

  eat(): void {
    console.log('Ptak je');
  }

  sleep(): void {
    console.log('Ptak śpi');
  }
}

// Latające ptaki
class FlyingBird extends Bird implements Flyable {
  makeSound(): void {
    console.log('Ptak wydaje dźwięk');
  }

  move(): void {
    this.fly();
  }

  fly(): void {
    console.log('Ptak leci');
  }
}

// Pływające ptaki
class SwimmingBird extends Bird implements Swimmable {
  makeSound(): void {
    console.log('Ptak wydaje dźwięk');
  }

  move(): void {
    this.swim();
  }

  swim(): void {
    console.log('Ptak pływa');
  }
}

// Konkretne implementacje
class Sparrow extends FlyingBird {
  makeSound(): void {
    console.log('Ćwir ćwir!');
  }

  fly(): void {
    console.log('Wróbel leci szybko');
  }
}

class Eagle extends FlyingBird {
  makeSound(): void {
    console.log('Krra!');
  }

  fly(): void {
    console.log('Orzeł szybuje majestatycznie');
  }
}

class Penguin extends SwimmingBird implements Walkable {
  makeSound(): void {
    console.log('Kwa kwa!');
  }

  swim(): void {
    console.log('Pingwin pływa zwinnie');
  }

  walk(): void {
    console.log('Pingwin chodzi po lodzie');
  }

  move(): void {
    // Pingwin może się poruszać na różne sposoby
    if (Math.random() > 0.5) {
      this.swim();
    } else {
      this.walk();
    }
  }
}

// Funkcje przestrzegające LSP
function makeAnimalMove(animal: Animal): void {
  animal.move(); // Zawsze zadziała poprawnie
}

function makeFlyableObjectFly(flyable: Flyable): void {
  flyable.fly(); // Tylko dla obiektów, które rzeczywiście potrafią latać
}

function makeSwimmableObjectSwim(swimmable: Swimmable): void {
  swimmable.swim(); // Tylko dla obiektów, które rzeczywiście potrafią pływać
}

// Testowanie
const birds: Bird[] = [
  new Sparrow(),
  new Eagle(),
  new Penguin()
];

birds.forEach(bird => {
  bird.makeSound();
  makeAnimalMove(bird); // Każdy ptak może się poruszać po swojemu
});

// Testowanie zdolności latania tylko dla latających ptaków
const flyingBirds: Flyable[] = [
  new Sparrow(),
  new Eagle()
  // Pingwin nie jest dodany, bo nie implementuje Flyable
];

flyingBirds.forEach(bird => {
  makeFlyableObjectFly(bird);
});

Teraz makeAnimalMove zadziała dla każdego ptaka, a pingwina nie dopiszesz do tablicy Flyable, bo kompilator zgłosi błąd.

I - Interface Segregation Principle (Zasada segregacji interfejsów)

Klasy nie powinny być zmuszone do implementowania interfejsów, z których nie korzystają. Strażnik wybiegu nie musi umieć pilotować helikoptera.

Naruszenie ISP

Jeden wielki interfejs zmusza prostą drukarkę do udawania, że umie wszystko:

// Naruszenie ISP - zbyt duży interfejs
interface MultiFunctionDevice {
  print(document: string): void;
  scan(document: string): string;
  fax(document: string, number: string): void;
  copy(document: string): string;
  email(document: string, address: string): void;
}

// Problem: prosta drukarka musi implementować wszystkie metody
class SimplePrinter implements MultiFunctionDevice {
  print(document: string): void {
    console.log(`Drukowanie: ${document}`);
  }

  // Wymuszenie implementacji nieużywanych metod
  scan(document: string): string {
    throw new Error('Drukarka nie obsługuje skanowania');
  }

  fax(document: string, number: string): void {
    throw new Error('Drukarka nie obsługuje faksów');
  }

  copy(document: string): string {
    throw new Error('Drukarka nie obsługuje kopiowania');
  }

  email(document: string, address: string): void {
    throw new Error('Drukarka nie obsługuje emaili');
  }
}

Cztery z pięciu metod rzucają wyjątek, co wyjdzie na jaw dopiero w trakcie działania.

Zgodne z ISP

Dzielimy interfejs na małe części, a każda klasa implementuje tylko to, czego potrzebuje:

// Zgodne z ISP - podzielone interfejsy

interface Printer {
  print(document: string): void;
}

interface Scanner {
  scan(document: string): string;
}

interface FaxMachine {
  fax(document: string, number: string): void;
}

interface Copier {
  copy(document: string): string;
}

interface EmailSender {
  email(document: string, address: string): void;
}

// Prosta drukarka implementuje tylko to, czego potrzebuje
class SimplePrinter implements Printer {
  print(document: string): void {
    console.log(`Drukowanie: ${document}`);
  }
}

// Skaner implementuje tylko skanowanie
class SimpleScanner implements Scanner {
  scan(document: string): string {
    console.log(`Skanowanie: ${document}`);
    return `Zeskanowany: ${document}`;
  }
}

// Urządzenie wielofunkcyjne implementuje potrzebne interfejsy
class MultiFunctionPrinter implements Printer, Scanner, Copier {
  print(document: string): void {
    console.log(`[MFP] Drukowanie: ${document}`);
  }

  scan(document: string): string {
    console.log(`[MFP] Skanowanie: ${document}`);
    return `Zeskanowany: ${document}`;
  }

  copy(document: string): string {
    console.log(`[MFP] Kopiowanie: ${document}`);
    const scanned = this.scan(document);
    this.print(scanned);
    return scanned;
  }
}

// Profesjonalne urządzenie biurowe
class OfficeMachine implements Printer, Scanner, FaxMachine, Copier, EmailSender {
  print(document: string): void {
    console.log(`[Office] Drukowanie: ${document}`);
  }

  scan(document: string): string {
    console.log(`[Office] Skanowanie: ${document}`);
    return `Zeskanowany: ${document}`;
  }

  fax(document: string, number: string): void {
    console.log(`[Office] Wysyłanie faksu ${document} na numer ${number}`);
  }

  copy(document: string): string {
    console.log(`[Office] Kopiowanie: ${document}`);
    return this.scan(document);
  }

  email(document: string, address: string): void {
    console.log(`[Office] Wysyłanie emaila ${document} na adres ${address}`);
  }
}

// Funkcje używające tylko potrzebnych interfejsów
class DocumentProcessor {
  static printDocument(printer: Printer, document: string): void {
    printer.print(document);
  }

  static scanDocument(scanner: Scanner, document: string): string {
    return scanner.scan(document);
  }

  static copyDocument(copier: Copier, document: string): string {
    return copier.copy(document);
  }
}

// Użycie
const simplePrinter = new SimplePrinter();
const simpleScanner = new SimpleScanner();
const mfp = new MultiFunctionPrinter();
const officeMachine = new OfficeMachine();

// Każde urządzenie używa tylko swoich możliwości
DocumentProcessor.printDocument(simplePrinter, 'Dokument 1');
DocumentProcessor.scanDocument(simpleScanner, 'Dokument 2');
DocumentProcessor.copyDocument(mfp, 'Dokument 3');
DocumentProcessor.printDocument(officeMachine, 'Dokument 4');

DocumentProcessor prosi dokładnie o to, czego używa, a OfficeMachine pokazuje, że klasa może implementować kilka interfejsów naraz.

D - Dependency Inversion Principle (Zasada odwrócenia zależności)

Moduły wysokiego poziomu nie powinny zależeć od modułów niskiego poziomu. Oba powinny zależeć od abstrakcji. Centrum dowodzenia korzysta z gniazdka, a nie z konkretnego generatora.

Naruszenie DIP

Tutaj UserService sam tworzy konkretną bazę MySQL i konkretną usługę maili:

// Naruszenie DIP - zależność od konkretnych implementacji

class MySQLDatabase {
  save(data: any): void {
    console.log('Zapisywanie do MySQL:', data);
  }

  find(id: string): any {
    console.log('Szukanie w MySQL:', id);
    return { id, data: 'mysql_data' };
  }
}

class EmailNotification {
  send(message: string, recipient: string): void {
    console.log(`Wysyłanie emaila do ${recipient}: ${message}`);
  }
}

// Problem: UserService zależy od konkretnych implementacji
class UserService {
  private database: MySQLDatabase; // Konkretna zależność
  private notification: EmailNotification; // Konkretna zależność

  constructor() {
    this.database = new MySQLDatabase(); // Tworzenie zależności wewnątrz klasy
    this.notification = new EmailNotification();
  }

  createUser(userData: any): void {
    this.database.save(userData);
    this.notification.send('Witaj!', userData.email);
  }

  getUser(id: string): any {
    return this.database.find(id);
  }
}

Zmiana bazy oznacza edycję serwisu, a w testach nie podmienisz jej na atrapę.

Zgodne z DIP

Teraz serwis zna tylko interfejsy Database, NotificationService i Logger, a konkretne klasy dostaje z zewnątrz, choćby z prostego kontenera DI:

// Zgodne z DIP - zależność od abstrakcji

// Abstrakcje (interfejsy)
interface Database {
  save(data: any): void;
  find(id: string): any;
  update(id: string, data: any): void;
  delete(id: string): boolean;
}

interface NotificationService {
  send(message: string, recipient: string): Promise<boolean>;
}

interface Logger {
  log(level: 'info' | 'warn' | 'error', message: string): void;
}

// Konkretne implementacje - niski poziom
class MySQLDatabase implements Database {
  save(data: any): void {
    console.log('Zapisywanie do MySQL:', data);
  }

  find(id: string): any {
    console.log('Szukanie w MySQL:', id);
    return { id, data: 'mysql_data' };
  }

  update(id: string, data: any): void {
    console.log(`Aktualizacja w MySQL ${id}:`, data);
  }

  delete(id: string): boolean {
    console.log('Usuwanie z MySQL:', id);
    return true;
  }
}

class PostgreSQLDatabase implements Database {
  save(data: any): void {
    console.log('Zapisywanie do PostgreSQL:', data);
  }

  find(id: string): any {
    console.log('Szukanie w PostgreSQL:', id);
    return { id, data: 'postgres_data' };
  }

  update(id: string, data: any): void {
    console.log(`Aktualizacja w PostgreSQL ${id}:`, data);
  }

  delete(id: string): boolean {
    console.log('Usuwanie z PostgreSQL:', id);
    return true;
  }
}

class MongoDatabase implements Database {
  save(data: any): void {
    console.log('Zapisywanie do MongoDB:', data);
  }

  find(id: string): any {
    console.log('Szukanie w MongoDB:', id);
    return { id, data: 'mongo_data' };
  }

  update(id: string, data: any): void {
    console.log(`Aktualizacja w MongoDB ${id}:`, data);
  }

  delete(id: string): boolean {
    console.log('Usuwanie z MongoDB:', id);
    return true;
  }
}

class EmailNotificationService implements NotificationService {
  async send(message: string, recipient: string): Promise<boolean> {
    console.log(`Wysyłanie emaila do ${recipient}: ${message}`);
    return true;
  }
}

class SMSNotificationService implements NotificationService {
  async send(message: string, recipient: string): Promise<boolean> {
    console.log(`Wysyłanie SMS do ${recipient}: ${message}`);
    return true;
  }
}

class SlackNotificationService implements NotificationService {
  async send(message: string, recipient: string): Promise<boolean> {
    console.log(`Wysyłanie wiadomości Slack do ${recipient}: ${message}`);
    return true;
  }
}

class ConsoleLogger implements Logger {
  log(level: 'info' | 'warn' | 'error', message: string): void {
    console.log(`[${level.toUpperCase()}] ${message}`);
  }
}

class FileLogger implements Logger {
  log(level: 'info' | 'warn' | 'error', message: string): void {
    console.log(`Zapisywanie do pliku [${level.toUpperCase()}]: ${message}`);
  }
}

// Wysokopoziomowy moduł - zależy tylko od abstrakcji
class UserService {
  constructor(
    private database: Database,
    private notificationService: NotificationService,
    private logger: Logger
  ) {}

  async createUser(userData: any): Promise<void> {
    try {
      this.logger.log('info', `Tworzenie użytkownika: ${userData.email}`);

      this.database.save(userData);

      await this.notificationService.send(
        'Witaj w naszej aplikacji!',
        userData.email
      );

      this.logger.log('info', `Użytkownik ${userData.email} został utworzony`);
    } catch (error) {
      this.logger.log('error', `Błąd podczas tworzenia użytkownika: ${error}`);
      throw error;
    }
  }

  getUser(id: string): any {
    this.logger.log('info', `Pobieranie użytkownika: ${id}`);
    return this.database.find(id);
  }

  async updateUser(id: string, userData: any): Promise<void> {
    try {
      this.logger.log('info', `Aktualizacja użytkownika: ${id}`);

      this.database.update(id, userData);

      await this.notificationService.send(
        'Twoje dane zostały zaktualizowane',
        userData.email
      );

      this.logger.log('info', `Użytkownik ${id} został zaktualizowany`);
    } catch (error) {
      this.logger.log('error', `Błąd podczas aktualizacji użytkownika: ${error}`);
      throw error;
    }
  }

  deleteUser(id: string): boolean {
    this.logger.log('info', `Usuwanie użytkownika: ${id}`);
    return this.database.delete(id);
  }
}

// Dependency Injection Container (uproszczony)
class DIContainer {
  private services = new Map<string, any>();

  register<T>(name: string, instance: T): void {
    this.services.set(name, instance);
  }

  get<T>(name: string): T {
    const service = this.services.get(name);
    if (!service) {
      throw new Error(`Service ${name} not found`);
    }
    return service;
  }
}

// Konfiguracja zależności
const container = new DIContainer();

// Rejestracja różnych implementacji
container.register<Database>('database', new PostgreSQLDatabase());
container.register<NotificationService>('notification', new EmailNotificationService());
container.register<Logger>('logger', new ConsoleLogger());

// Utworzenie serwisu ze wstrzykniętymi zależnościami
const userService = new UserService(
  container.get<Database>('database'),
  container.get<NotificationService>('notification'),
  container.get<Logger>('logger')
);

// Testowanie
userService.createUser({
  id: '1',
  name: 'Jan Kowalski',
  email: 'jan@example.com'
});

// Łatwe przełączanie implementacji
const mobileUserService = new UserService(
  new MongoDatabase(),              // Inna baza danych
  new SMSNotificationService(),     // Inne powiadomienia
  new FileLogger()                  // Inne logowanie
);

mobileUserService.createUser({
  id: '2',
  name: 'Anna Nowak',
  email: '+48123456789'
});

Kod UserService nie zmienił się ani o znak, a działa raz z PostgreSQL i mailem, raz z MongoDB i SMS-em. Wstrzykiwanie przez konstruktor polecam jako domyślny styl: w testach podajesz po prostu atrapy.

Event Bus

Event Bus to wspólny kanał zdarzeń, przez który moduły komunikują się bez bezpośrednich zależności, jak strażnicy przez radio parku. Nadawca wywołuje publish, a zainteresowani nasłuchują przez subscribe:

class EventBus {
  constructor() {
    this.listeners = new Map(); // nazwa zdarzenia -> tablica callbacków
  }

  subscribe(event, callback) {
    if (!this.listeners.has(event)) this.listeners.set(event, []);
    this.listeners.get(event).push(callback);
  }

  unsubscribe(event, callback) {
    const callbacks = this.listeners.get(event) || [];
    this.listeners.set(event, callbacks.filter(cb => cb !== callback));
  }

  publish(event, data) {
    (this.listeners.get(event) || []).forEach(cb => cb(data));
  }
}

const bus = new EventBus();
bus.subscribe('fence:breach', data => console.log('Alarm w sektorze', data.sector));
bus.publish('fence:breach', { sector: 'B6' });

Moduł ogrodzeń nie wie, kto odbierze alarm, a system alarmowy go nie importuje: oba znają tylko szynę zdarzeń, czyli abstrakcję.

Singleton i rejestr modułów

Singleton gwarantuje jedną instancję, jak jedno centrum dowodzenia: zapamiętuje ją w statycznym polu, a każde kolejne new zwraca właśnie ją:

class ParkCore {
  constructor() {
    if (ParkCore.instance) return ParkCore.instance;
    ParkCore.instance = this;
    this.modules = new Map();
  }

  registerModule(name, module) {
    this.modules.set(name, module);
  }

  getModule(name) {
    return this.modules.get(name);
  }

  init() {
    this.modules.forEach(module => module.init?.());
  }
}

console.log(new ParkCore() === new ParkCore()); // true

Nowy moduł rejestrujesz bez zmian w rdzeniu (zasada otwarte/zamknięte). Singleton to jednak ukryta zmienna globalna, więc lepiej przekazuj go przez konstruktor. Moduły chroń wzorcem Module: daje enkapsulację i nie zaśmieca globalnego zakresu.

Praktyczny przykład - System e-commerce zgodny z SOLID

Na koniec pięć zasad w jednym systemie zamówień, a komentarze z literami S, O, L, I i D pokazują, gdzie działa która:

// Kompleksowy przykład zastosowania wszystkich zasad SOLID

// Abstrakcje
interface Product {
  id: string;
  name: string;
  price: number;
  category: string;
  inStock: boolean;
}

interface ProductRepository {
  findById(id: string): Promise<Product | null>;
  findByCategory(category: string): Promise<Product[]>;
  save(product: Product): Promise<void>;
  update(id: string, updates: Partial<Product>): Promise<void>;
  delete(id: string): Promise<boolean>;
}

interface PricingStrategy {
  calculatePrice(product: Product, quantity: number): number;
}

interface DiscountCalculator {
  calculateDiscount(product: Product, quantity: number): number;
}

interface InventoryService {
  checkAvailability(productId: string, quantity: number): Promise<boolean>;
  reserveItems(productId: string, quantity: number): Promise<boolean>;
  releaseReservation(productId: string, quantity: number): Promise<void>;
}

interface OrderRepository {
  save(order: Order): Promise<void>;
  findById(orderId: string): Promise<Order | null>;
}

interface NotificationService {
  sendOrderConfirmation(order: Order): Promise<void>;
  sendInventoryAlert(productId: string): Promise<void>;
}

// S - Single Responsibility
class RegularPricingStrategy implements PricingStrategy {
  calculatePrice(product: Product, quantity: number): number {
    return product.price * quantity;
  }
}

class BulkDiscountStrategy implements PricingStrategy {
  constructor(private discountCalculator: DiscountCalculator) {}

  calculatePrice(product: Product, quantity: number): number {
    const basePrice = product.price * quantity;
    const discount = this.discountCalculator.calculateDiscount(product, quantity);
    return basePrice - discount;
  }
}

class QuantityDiscountCalculator implements DiscountCalculator {
  calculateDiscount(product: Product, quantity: number): number {
    if (quantity >= 10) return product.price * quantity * 0.1;
    if (quantity >= 5) return product.price * quantity * 0.05;
    return 0;
  }
}

class CategoryDiscountCalculator implements DiscountCalculator {
  private discountRates = new Map([
    ['electronics', 0.15],
    ['books', 0.1],
    ['clothing', 0.2]
  ]);

  calculateDiscount(product: Product, quantity: number): number {
    const rate = this.discountRates.get(product.category) || 0;
    return product.price * quantity * rate;
  }
}

// O - Open/Closed - łatwe dodawanie nowych strategii
class SeasonalPricingStrategy implements PricingStrategy {
  constructor(
    private basePricingStrategy: PricingStrategy,
    private seasonalMultiplier: number
  ) {}

  calculatePrice(product: Product, quantity: number): number {
    const basePrice = this.basePricingStrategy.calculatePrice(product, quantity);
    return basePrice * this.seasonalMultiplier;
  }
}

// L - Liskov Substitution - wszystkie strategie są zamienne
class PremiumPricingStrategy implements PricingStrategy {
  calculatePrice(product: Product, quantity: number): number {
    return product.price * quantity * 1.2; // 20% premium
  }
}

// I - Interface Segregation - małe, dedykowane interfejsy
interface OrderItem {
  productId: string;
  quantity: number;
  unitPrice: number;
  totalPrice: number;
}

interface Order {
  id: string;
  customerId: string;
  items: OrderItem[];
  totalAmount: number;
  status: 'pending' | 'confirmed' | 'shipped' | 'delivered';
  createdAt: Date;
}

// D - Dependency Inversion
class OrderService {
  constructor(
    private productRepository: ProductRepository,
    private orderRepository: OrderRepository,
    private inventoryService: InventoryService,
    private pricingStrategy: PricingStrategy,
    private notificationService: NotificationService
  ) {}

  async createOrder(customerId: string, items: Array<{productId: string, quantity: number}>): Promise<Order> {
    const orderItems: OrderItem[] = [];
    let totalAmount = 0;

    // Sprawdzenie dostępności i obliczenie cen
    for (const item of items) {
      const product = await this.productRepository.findById(item.productId);
      if (!product) {
        throw new Error(`Produkt ${item.productId} nie został znaleziony`);
      }

      const isAvailable = await this.inventoryService.checkAvailability(item.productId, item.quantity);
      if (!isAvailable) {
        throw new Error(`Niewystarczająca ilość produktu ${product.name}`);
      }

      const totalPrice = this.pricingStrategy.calculatePrice(product, item.quantity);

      orderItems.push({
        productId: item.productId,
        quantity: item.quantity,
        unitPrice: product.price,
        totalPrice
      });

      totalAmount += totalPrice;
    }

    // Rezerwacja produktów
    for (const item of orderItems) {
      await this.inventoryService.reserveItems(item.productId, item.quantity);
    }

    // Utworzenie zamówienia
    const order: Order = {
      id: 'order_' + Math.random().toString(36).slice(2, 11),
      customerId,
      items: orderItems,
      totalAmount,
      status: 'pending',
      createdAt: new Date()
    };

    await this.orderRepository.save(order);
    await this.notificationService.sendOrderConfirmation(order);

    return order;
  }

  async confirmOrder(orderId: string): Promise<void> {
    const order = await this.orderRepository.findById(orderId);
    if (!order) {
      throw new Error('Zamówienie nie zostało znalezione');
    }

    order.status = 'confirmed';
    await this.orderRepository.save(order);
  }
}

// Przykład użycia z różnymi strategiami cenowymi
function createOrderServiceWithRegularPricing(): OrderService {
  return new OrderService(
    new InMemoryProductRepository(),
    new InMemoryOrderRepository(),
    new SimpleInventoryService(),
    new RegularPricingStrategy(),
    new EmailNotificationService()
  );
}

function createOrderServiceWithBulkDiscount(): OrderService {
  return new OrderService(
    new InMemoryProductRepository(),
    new InMemoryOrderRepository(),
    new SimpleInventoryService(),
    new BulkDiscountStrategy(new QuantityDiscountCalculator()),
    new EmailNotificationService()
  );
}

function createOrderServiceWithSeasonalPricing(): OrderService {
  const basePricing = new BulkDiscountStrategy(new CategoryDiscountCalculator());
  const seasonalPricing = new SeasonalPricingStrategy(basePricing, 0.8); // 20% zniżki

  return new OrderService(
    new InMemoryProductRepository(),
    new InMemoryOrderRepository(),
    new SimpleInventoryService(),
    seasonalPricing,
    new SlackNotificationService()
  );
}

// Implementacje pomocnicze (uproszczone)
class InMemoryProductRepository implements ProductRepository {
  private products = new Map<string, Product>();

  async findById(id: string): Promise<Product | null> {
    return this.products.get(id) || null;
  }

  async findByCategory(category: string): Promise<Product[]> {
    return Array.from(this.products.values()).filter(p => p.category === category);
  }

  async save(product: Product): Promise<void> {
    this.products.set(product.id, product);
  }

  async update(id: string, updates: Partial<Product>): Promise<void> {
    const product = this.products.get(id);
    if (product) {
      this.products.set(id, { ...product, ...updates });
    }
  }

  async delete(id: string): Promise<boolean> {
    return this.products.delete(id);
  }
}

class InMemoryOrderRepository implements OrderRepository {
  private orders = new Map<string, Order>();

  async save(order: Order): Promise<void> {
    this.orders.set(order.id, order);
  }

  async findById(orderId: string): Promise<Order | null> {
    return this.orders.get(orderId) || null;
  }
}

class SimpleInventoryService implements InventoryService {
  private inventory = new Map<string, number>();

  async checkAvailability(productId: string, quantity: number): Promise<boolean> {
    const available = this.inventory.get(productId) || 0;
    return available >= quantity;
  }

  async reserveItems(productId: string, quantity: number): Promise<boolean> {
    const available = this.inventory.get(productId) || 0;
    if (available >= quantity) {
      this.inventory.set(productId, available - quantity);
      return true;
    }
    return false;
  }

  async releaseReservation(productId: string, quantity: number): Promise<void> {
    const current = this.inventory.get(productId) || 0;
    this.inventory.set(productId, current + quantity);
  }
}

class EmailNotificationService implements NotificationService {
  async sendOrderConfirmation(order: Order): Promise<void> {
    console.log(`Email: Potwierdzenie zamówienia ${order.id} wysłane`);
  }

  async sendInventoryAlert(productId: string): Promise<void> {
    console.log(`Email: Alert o niskim stanie magazynowym dla ${productId}`);
  }
}

class SlackNotificationService implements NotificationService {
  async sendOrderConfirmation(order: Order): Promise<void> {
    console.log(`Slack: Potwierdzenie zamówienia ${order.id} wysłane`);
  }

  async sendInventoryAlert(productId: string): Promise<void> {
    console.log(`Slack: Alert o niskim stanie magazynowym dla ${productId}`);
  }
}

OrderService nie wie, czy liczy ceny zwykłe, hurtowe czy sezonowe, bo strategię dostaje z zewnątrz, a jego kod pozostaje nietknięty.

Podsumowanie zasad SOLID

  1. Single Responsibility - jedna klasa, jedna odpowiedzialność
  2. Open/Closed - otwarte na rozszerzenie, zamknięte na modyfikację
  3. Liskov Substitution - obiekty pochodne mogą zastąpić bazowe
  4. Interface Segregation - małe, dedykowane interfejsy
  5. Dependency Inversion - zależność od abstrakcji, nie implementacji

Kod zgodny z SOLID jest łatwiejszy w utrzymaniu, testowalny, skalowalny i czytelny. Nie stosuj jednak zasad na siłę: trzy linijki nie potrzebują pięciu interfejsów. W edytorze poniżej uzupełnisz własny EventBus, a w kolejnej lekcji programowanie funkcyjne osiągnie podobne cele czystymi funkcjami.

Pamiętaj: dobry park to wiele małych, wyspecjalizowanych systemów połączonych abstrakcjami, a nie jeden gigantyczny panel sterowania.

Kod do tej lekcji: index.js
// Wzorzec Observer - Event Bus
// Ćwiczenie: Stwórz system zdarzeń dla Parku

class EventBus {
  constructor() {
    this.listeners = {};
  }

  // Zaimplementuj metody:
  // subscribe(event, callback) - subskrypcja
  // unsubscribe(event, callback) - wypisanie
  // publish(event, data) - publikacja zdarzenia

  subscribe(event, callback) {
    // Twój kod tutaj
  }

  publish(event, data) {
    // Twój kod tutaj
  }
}

const bus = new EventBus();
bus.subscribe("alert", (data) => console.log("Alert:", data));
bus.publish("alert", { level: "HIGH", message: "Ogrodzenie uszkodzone!" });

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Do czego służy Event Bus w architekturze aplikacji?

  2. 2. Co zapewnia wzorzec Module w JavaScript?

Zadania praktyczne w grze

  • Edytor kodu

    W pliku index.js jest klasa ParkCore, która trzyma moduły parku w Map (this.modules). Uzupełnij luki metodami Map: ___BLANK1___ sprawdza, czy nazwa modułu jest już zajęta (wtedy registerModule zwraca false i nie nadpisuje modułu), ___BLANK2___ zwraca moduł zapisany pod nazwą, a ___BLANK3___ przechodzi po wszystkich modułach, żeby init() wywołał init() każdego modułu, który ją ma, i zwrócił liczbę zainicjalizowanych modułów.

  • Klikanie w kolejności

    Ułóż elementy implementacji wzorca Singleton.

  • Edytor kodu

    W pliku index.js jest klasa EventBus z lekcji o SOLID. Uzupełnij luki: ___BLANK1___ to metoda tablicy, która dopisuje callback na koniec listy zdarzenia, ___BLANK2___ to metoda tablicy, która zwraca nową tablicę bez usuwanego callbacku, a ___BLANK3___ to wywołanie callbacku cb z danymi zdarzenia. publish ma przekazać dane każdemu subskrybentowi zdarzenia, a po unsubscribe usunięty callback nie może już nic dostać.

  1. PytanieQuiz: Event Bus
  2. PytanieWzorzec Module
  3. Zadanie z kodemĆwiczenie: Struktura projektu
  4. Kliknij w kolejnościSortowanie: Singleton Pattern
  5. Zadanie z kodemĆwiczenie: Event Bus

Przydatne artykuły