Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura
Zasady SOLID w JavaScript/TypeScript
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()); // trueNowy 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
- Single Responsibility - jedna klasa, jedna odpowiedzialność
- Open/Closed - otwarte na rozszerzenie, zamknięte na modyfikację
- Liskov Substitution - obiekty pochodne mogą zastąpić bazowe
- Interface Segregation - małe, dedykowane interfejsy
- 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. Do czego służy Event Bus w architekturze aplikacji?
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ć.