Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura
Wzorce zarządzania stanem w JavaScript/TypeScript
W tej lekcji5
W centrum dowodzenia parku stan zmienia się co sekundę: otwarte bramy, nakarmione dinozaury, alarmy. Gdy każdy moduł zmienia te dane po swojemu, po awarii nikt nie wie, kto i kiedy otworzył bramę wybiegu Velociraptorów. Pomogą w tym wzorce zarządzania stanem. Poznasz trzy: Flux, Event Sourcing i maszyny stanów (State Machines).
Flux Architecture - Jednokierunkowy przepływ danych
Flux to wzorzec architektury aplikacji, który wprowadza jednokierunkowy przepływ danych, co czyni stan aplikacji bardziej przewidywalnym i łatwiejszym do debugowania. Zaproponował go Facebook: akcja trafia do dispatchera, ten przekazuje ją do store'ów, a widok odświeża się po zmianie.
Podstawowe składniki Flux
Akcja (Action) to obiekt z polem type i opcjonalnym payload, dispatcher rozsyła akcje, store przechowuje stan i powiadamia subskrybentów, a action creators to funkcje tworzące akcje:
// Typy dla Flux
type Action<T = any> = {
type: string;
payload?: T;
};
type Listener = () => void;
// Store - przechowuje stan aplikacji
class Store<T> {
private state: T;
private listeners: Listener[] = [];
constructor(initialState: T) {
this.state = initialState;
}
getState(): T {
return this.state;
}
protected setState(newState: T): void {
this.state = newState;
this.emitChange();
}
subscribe(listener: Listener): () => void {
this.listeners.push(listener);
// Zwracamy funkcję do unsubscribe
return () => {
const index = this.listeners.indexOf(listener);
if (index > -1) {
this.listeners.splice(index, 1);
}
};
}
private emitChange(): void {
this.listeners.forEach(listener => listener());
}
}
// Dispatcher - centralny hub dla wszystkich akcji
class Dispatcher {
private callbacks: Array<(action: Action) => void> = [];
register(callback: (action: Action) => void): string {
const id = Math.random().toString(36).slice(2, 11);
this.callbacks.push(callback);
return id;
}
dispatch(action: Action): void {
console.log('Dispatching action:', action);
this.callbacks.forEach(callback => {
callback(action);
});
}
}
// Action Creators - funkcje tworzące akcje
const TodoActions = {
addTodo: (text: string): Action<{ text: string }> => ({
type: 'ADD_TODO',
payload: { text }
}),
toggleTodo: (id: string): Action<{ id: string }> => ({
type: 'TOGGLE_TODO',
payload: { id }
}),
deleteTodo: (id: string): Action<{ id: string }> => ({
type: 'DELETE_TODO',
payload: { id }
}),
setFilter: (filter: 'all' | 'active' | 'completed'): Action<{ filter: string }> => ({
type: 'SET_FILTER',
payload: { filter }
})
};
// Stan aplikacji
interface Todo {
id: string;
text: string;
completed: boolean;
createdAt: Date;
}
interface TodoState {
todos: Todo[];
filter: 'all' | 'active' | 'completed';
}
// Implementacja TodoStore
class TodoStore extends Store<TodoState> {
constructor(dispatcher: Dispatcher) {
super({
todos: [],
filter: 'all'
});
// Rejestracja w dispatcherze
dispatcher.register((action: Action) => {
this.handleAction(action);
});
}
private handleAction(action: Action): void {
const currentState = this.getState();
switch (action.type) {
case 'ADD_TODO':
this.setState({
...currentState,
todos: [
...currentState.todos,
{
id: Math.random().toString(36).slice(2, 11),
text: action.payload.text,
completed: false,
createdAt: new Date()
}
]
});
break;
case 'TOGGLE_TODO':
this.setState({
...currentState,
todos: currentState.todos.map(todo =>
todo.id === action.payload.id
? { ...todo, completed: !todo.completed }
: todo
)
});
break;
case 'DELETE_TODO':
this.setState({
...currentState,
todos: currentState.todos.filter(todo => todo.id !== action.payload.id)
});
break;
case 'SET_FILTER':
this.setState({
...currentState,
filter: action.payload.filter
});
break;
case 'LOAD_TODOS_SUCCESS':
this.setState({
...currentState,
todos: action.payload.todos
});
break;
default:
// Brak zmian stanu dla nieznanych akcji
break;
}
}
// Selektory - funkcje do pobierania przetworzonych danych
getFilteredTodos(): Todo[] {
const { todos, filter } = this.getState();
switch (filter) {
case 'active':
return todos.filter(todo => !todo.completed);
case 'completed':
return todos.filter(todo => todo.completed);
default:
return todos;
}
}
getStats() {
const todos = this.getState().todos;
return {
total: todos.length,
completed: todos.filter(todo => todo.completed).length,
active: todos.filter(todo => !todo.completed).length
};
}
}
// Użycie Flux
const dispatcher = new Dispatcher();
const todoStore = new TodoStore(dispatcher);
// Subskrypcja na zmiany
const unsubscribe = todoStore.subscribe(() => {
console.log('Stan się zmienił:', {
todos: todoStore.getFilteredTodos(),
stats: todoStore.getStats(),
filter: todoStore.getState().filter
});
});
// Wykonywanie akcji
dispatcher.dispatch(TodoActions.addTodo('Nauka Flux'));
dispatcher.dispatch(TodoActions.addTodo('Implementacja TodoApp'));
dispatcher.dispatch(TodoActions.toggleTodo(todoStore.getState().todos[0].id));
dispatcher.dispatch(TodoActions.setFilter('active'));Metoda setState jest chroniona, więc nowy stan ustawia wyłącznie akcja przepuszczona przez dispatcher. getState zwraca jednak referencję do obiektu stanu, przez którą da się go zmienić z pominięciem dispatchera. Dlatego nowy stan warto zamrozić, zanim store powiadomi subskrybentów: Object.freeze działa płytko, więc zamraża się też zagnieżdżone tablice, takie jak todos. Każdy element ma jedną odpowiedzialność (SRP), a store zwykle istnieje w jednej instancji, jak Singleton. W Reduxie logikę z handleAction przenosi się do reducera: czystej funkcji, która z obecnego stanu i akcji tworzy nowy stan.
Zaawansowany Flux z Middleware
Middleware to warstwa, przez którą każda akcja przechodzi przed dotarciem do store'a, jak śluza przed wybiegiem. Tu dodaje logowanie, debugowanie i obsługę akcji asynchronicznych:
// Middleware dla Flux
type Middleware = (action: Action, next: (action: Action) => void) => void;
class EnhancedDispatcher extends Dispatcher {
private middlewares: Middleware[] = [];
use(middleware: Middleware): void {
this.middlewares.push(middleware);
}
dispatch(action: Action): void {
let index = 0;
const next = (currentAction: Action) => {
if (index < this.middlewares.length) {
const middleware = this.middlewares[index++];
middleware(currentAction, next);
} else {
super.dispatch(currentAction);
}
};
next(action);
}
}
// Middleware do logowania
const loggingMiddleware: Middleware = (action, next) => {
console.group(`Action: ${action.type}`);
console.log('Payload:', action.payload);
console.time('Action Duration');
next(action);
console.timeEnd('Action Duration');
console.groupEnd();
};
// Middleware do debugowania
const debugMiddleware: Middleware = (action, next) => {
if (process.env.NODE_ENV === 'development') {
console.log('Debug: Before action', action);
}
next(action);
if (process.env.NODE_ENV === 'development') {
console.log('Debug: After action', action);
}
};
// Middleware do obsługi akcji asynchronicznych
const asyncMiddleware: Middleware = (action, next) => {
if (typeof action.payload === 'function') {
// To jest akcja asynchroniczna
action.payload((asyncAction: Action) => {
next(asyncAction);
});
} else {
next(action);
}
};
// Async Action Creator
const AsyncTodoActions = {
loadTodos: () => ({
type: 'ASYNC_ACTION',
payload: (dispatch: (action: Action) => void) => {
// Symulacja wywołania API
setTimeout(() => {
dispatch({
type: 'LOAD_TODOS_SUCCESS',
payload: {
todos: [
{ id: '1', text: 'Todo z API', completed: false, createdAt: new Date() }
]
}
});
}, 1000);
}
})
};
// Użycie Enhanced Dispatcher
const enhancedDispatcher = new EnhancedDispatcher();
enhancedDispatcher.use(loggingMiddleware);
enhancedDispatcher.use(debugMiddleware);
enhancedDispatcher.use(asyncMiddleware);
const enhancedTodoStore = new TodoStore(enhancedDispatcher);Każdy middleware decyduje, czy wywołać next, więc może przerwać, opóźnić albo wzbogacić akcję. Nowe zachowanie dopisujesz przez use, bez edycji klasy, zgodnie z zasadą otwarte/zamknięte.
Event Sourcing - Historia zdarzeń jako źródło prawdy
Event Sourcing to wzorzec, w którym stan aplikacji jest określany przez sekwencję zdarzeń, zamiast przechowywania aktualnego stanu bezpośrednio. To jak dziennik strażnika: nie nadpisujesz tablicy ze stanem wybiegu, tylko zapisujesz każde zdarzenie, a stan odtwarzasz, czytając dziennik od początku.
Podstawowa implementacja Event Sourcing
Agregat (Aggregate) to obiekt, którego stan budujemy z eventów, tutaj User. Metody takie jak changeEmail nie zmieniają stanu, tylko zwracają nowe eventy, a zmianę wykonuje dopiero apply:
// Typy dla Event Sourcing
interface Event {
id: string;
type: string;
data: any;
timestamp: Date;
version: number;
}
interface Aggregate {
id: string;
version: number;
apply(event: Event): void;
}
// Event Store - przechowuje wszystkie eventy
class EventStore {
private events: Map<string, Event[]> = new Map();
async saveEvents(aggregateId: string, events: Event[], expectedVersion: number): Promise<void> {
const existingEvents = this.events.get(aggregateId) || [];
if (existingEvents.length !== expectedVersion) {
throw new Error('Concurrency conflict: unexpected version');
}
// Dodawanie nowych eventów
const newEvents = events.map((event, index) => ({
...event,
version: expectedVersion + index + 1,
timestamp: new Date()
}));
this.events.set(aggregateId, [...existingEvents, ...newEvents]);
console.log(`Saved ${newEvents.length} events for aggregate ${aggregateId}`);
}
async getEvents(aggregateId: string, fromVersion: number = 0): Promise<Event[]> {
const events = this.events.get(aggregateId) || [];
return events.filter(event => event.version > fromVersion);
}
async getAllEvents(): Promise<Event[]> {
const allEvents: Event[] = [];
for (const events of this.events.values()) {
allEvents.push(...events);
}
return allEvents.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
}
}
// Definicje eventów
const UserEvents = {
UserCreated: (data: { name: string; email: string }) => ({
type: 'UserCreated',
data
}),
UserEmailChanged: (data: { email: string }) => ({
type: 'UserEmailChanged',
data
}),
UserDeactivated: (data: { reason: string }) => ({
type: 'UserDeactivated',
data
}),
UserReactivated: () => ({
type: 'UserReactivated',
data: {}
})
};
// User Aggregate
class User implements Aggregate {
id: string;
version: number = 0;
name: string = '';
email: string = '';
isActive: boolean = true;
createdAt?: Date;
deactivatedAt?: Date;
constructor(id: string) {
this.id = id;
}
// Metody do tworzenia eventów (commands)
static create(id: string, name: string, email: string): { user: User; events: any[] } {
const user = new User(id);
const events = [UserEvents.UserCreated({ name, email })];
return { user, events };
}
changeEmail(newEmail: string): any[] {
if (this.email === newEmail) {
return []; // Brak zmian
}
if (!this.isActive) {
throw new Error('Cannot change email for deactivated user');
}
return [UserEvents.UserEmailChanged({ email: newEmail })];
}
deactivate(reason: string): any[] {
if (!this.isActive) {
return []; // Już nieaktywny
}
return [UserEvents.UserDeactivated({ reason })];
}
reactivate(): any[] {
if (this.isActive) {
return []; // Już aktywny
}
return [UserEvents.UserReactivated()];
}
// Aplikowanie eventów do zmiany stanu
apply(event: Event): void {
switch (event.type) {
case 'UserCreated':
this.name = event.data.name;
this.email = event.data.email;
this.createdAt = event.timestamp;
this.isActive = true;
break;
case 'UserEmailChanged':
this.email = event.data.email;
break;
case 'UserDeactivated':
this.isActive = false;
this.deactivatedAt = event.timestamp;
break;
case 'UserReactivated':
this.isActive = true;
this.deactivatedAt = undefined;
break;
default:
throw new Error(`Unknown event type: ${event.type}`);
}
this.version = event.version;
}
// Odtwarzanie stanu z eventów
static fromHistory(id: string, events: Event[]): User {
const user = new User(id);
events.forEach(event => user.apply(event));
return user;
}
}
// Repository dla User Aggregate
class UserRepository {
constructor(private eventStore: EventStore) {}
async save(user: User, newEvents: any[]): Promise<void> {
if (newEvents.length === 0) return;
const events = newEvents.map(eventData => ({
id: Math.random().toString(36).slice(2, 11),
type: eventData.type,
data: eventData.data,
timestamp: new Date(),
version: 0 // Zostanie ustawiona w EventStore
}));
await this.eventStore.saveEvents(user.id, events, user.version);
// Aplikowanie zapisanych eventów (z wersjami nadanymi przez EventStore) do aggregate
const savedEvents = await this.eventStore.getEvents(user.id, user.version);
savedEvents.forEach(event => user.apply(event));
}
async getById(id: string): Promise<User | null> {
const events = await this.eventStore.getEvents(id);
if (events.length === 0) {
return null;
}
return User.fromHistory(id, events);
}
}
// Użycie Event Sourcing
async function demonstrateEventSourcing() {
const eventStore = new EventStore();
const userRepository = new UserRepository(eventStore);
// Tworzenie użytkownika
const { user, events } = User.create('user1', 'Jan Kowalski', 'jan@example.com');
await userRepository.save(user, events);
console.log('Użytkownik po utworzeniu:', user);
// Zmiana emaila
const emailChangeEvents = user.changeEmail('jan.kowalski@example.com');
await userRepository.save(user, emailChangeEvents);
console.log('Użytkownik po zmianie emaila:', user);
// Dezaktywacja
const deactivateEvents = user.deactivate('User requested account deletion');
await userRepository.save(user, deactivateEvents);
console.log('Użytkownik po dezaktywacji:', user);
// Reaktywacja
const reactivateEvents = user.reactivate();
await userRepository.save(user, reactivateEvents);
console.log('Użytkownik po reaktywacji:', user);
// Odtworzenie stanu z eventów
const reconstructedUser = await userRepository.getById('user1');
console.log('Odtworzony użytkownik:', reconstructedUser);
// Historia wszystkich eventów
const allEvents = await eventStore.getAllEvents();
console.log('Historia eventów:', allEvents);
}
demonstrateEventSourcing();EventStore pilnuje wersji: jeśli ktoś w międzyczasie dopisał event, zapis kończy się konfliktem (optymistyczna kontrola współbieżności). Dlatego repozytorium aplikuje eventy z wersjami nadanymi przez magazyn, a fromHistory odtwarza użytkownika z samej historii.
Projektory i Read Models
Czytanie całej historii przy każdym pytaniu byłoby wolne. Projektor słucha eventów i buduje z nich model gotowy do odczytu (read model), na przykład statystyki:
// Projektor - tworzy read modele z eventów
abstract class Projector {
abstract getProjectionName(): string;
abstract handle(event: Event): Promise<void>;
}
// Read Model dla statystyk użytkowników
interface UserStats {
totalUsers: number;
activeUsers: number;
deactivatedUsers: number;
emailChanges: number;
}
class UserStatsProjector extends Projector {
private stats: UserStats = {
totalUsers: 0,
activeUsers: 0,
deactivatedUsers: 0,
emailChanges: 0
};
getProjectionName(): string {
return 'UserStats';
}
async handle(event: Event): Promise<void> {
switch (event.type) {
case 'UserCreated':
this.stats.totalUsers++;
this.stats.activeUsers++;
break;
case 'UserEmailChanged':
this.stats.emailChanges++;
break;
case 'UserDeactivated':
this.stats.activeUsers--;
this.stats.deactivatedUsers++;
break;
case 'UserReactivated':
this.stats.activeUsers++;
this.stats.deactivatedUsers--;
break;
}
console.log(`[UserStatsProjector] Updated stats:`, this.stats);
}
getStats(): UserStats {
return { ...this.stats };
}
}
// Event Bus dla projektorów
class EventBus {
private projectors: Projector[] = [];
registerProjector(projector: Projector): void {
this.projectors.push(projector);
}
async publishEvent(event: Event): Promise<void> {
console.log(`Publishing event: ${event.type}`);
const promises = this.projectors.map(projector =>
projector.handle(event).catch(error => {
console.error(`Error in projector ${projector.getProjectionName()}:`, error);
})
);
await Promise.all(promises);
}
}
// Enhanced Event Store z Event Bus
class EnhancedEventStore extends EventStore {
constructor(private eventBus: EventBus) {
super();
}
async saveEvents(aggregateId: string, events: Event[], expectedVersion: number): Promise<void> {
await super.saveEvents(aggregateId, events, expectedVersion);
// Publikowanie eventów do projektorów
const savedEvents = await this.getEvents(aggregateId, expectedVersion);
for (const event of savedEvents) {
await this.eventBus.publishEvent(event);
}
}
}
// Użycie z projektorami
async function demonstrateProjectors() {
const eventBus = new EventBus();
const userStatsProjector = new UserStatsProjector();
eventBus.registerProjector(userStatsProjector);
const enhancedEventStore = new EnhancedEventStore(eventBus);
const userRepository = new UserRepository(enhancedEventStore);
// Wykonanie operacji - projektory będą automatycznie aktualizowane
const { user, events } = User.create('user2', 'Anna Nowak', 'anna@example.com');
await userRepository.save(user, events);
const emailChangeEvents = user.changeEmail('anna.nowak@example.com');
await userRepository.save(user, emailChangeEvents);
console.log('Finalne statystyki:', userStatsProjector.getStats());
}
demonstrateProjectors();Projektor nie zmienia historii, tylko ją streszcza, więc nowy możesz dodać w dowolnej chwili i zasilić istniejącymi eventami.
State Machines (Maszyny stanów) z XState
Maszyny stanów pozwalają na modelowanie złożonych przepływów stanów w sposób deklaratywny i przewidywalny. Maszyna jest zawsze w dokładnie jednym stanie, a przejście następuje tylko po zdarzeniu dozwolonym w tym stanie, jak brama, której nie otworzysz w trakcie karmienia.
Podstawowa maszyna stanów
Najpierw własna maszyna. Każdy stan ma mapę on, w której zdarzenie wskazuje kolejny stan, oraz opcjonalne entry i exit, uruchamiane przy wejściu i wyjściu:
// Implementacja prostej maszyny stanów (bez XState)
interface StateDefinition {
on: Record<string, string>;
entry?: () => void;
exit?: () => void;
}
interface MachineConfig {
id: string;
initial: string;
states: Record<string, StateDefinition>;
}
class StateMachine {
private currentState: string;
private config: MachineConfig;
private listeners: Array<(state: string) => void> = [];
constructor(config: MachineConfig) {
this.config = config;
this.currentState = config.initial;
this.executeEntry();
}
getCurrentState(): string {
return this.currentState;
}
send(event: string): void {
const currentStateConfig = this.config.states[this.currentState];
const nextState = currentStateConfig.on[event];
if (!nextState) {
console.warn(`Event "${event}" not handled in state "${this.currentState}"`);
return;
}
this.transition(nextState);
}
private transition(nextState: string): void {
if (!this.config.states[nextState]) {
throw new Error(`State "${nextState}" not defined`);
}
console.log(`Transition: ${this.currentState} -> ${nextState}`);
// Wyjście z bieżącego stanu
this.executeExit();
// Zmiana stanu
const previousState = this.currentState;
this.currentState = nextState;
// Wejście do nowego stanu
this.executeEntry();
// Powiadomienie subskrybentów
this.listeners.forEach(listener => listener(this.currentState));
}
private executeEntry(): void {
const stateConfig = this.config.states[this.currentState];
if (stateConfig.entry) {
stateConfig.entry();
}
}
private executeExit(): void {
const stateConfig = this.config.states[this.currentState];
if (stateConfig.exit) {
stateConfig.exit();
}
}
subscribe(listener: (state: string) => void): () => void {
this.listeners.push(listener);
return () => {
const index = this.listeners.indexOf(listener);
if (index > -1) {
this.listeners.splice(index, 1);
}
};
}
}
// Przykład: Maszyna stanów dla procesu zamówienia
const orderMachine = new StateMachine({
id: 'order',
initial: 'cart',
states: {
cart: {
on: {
CHECKOUT: 'checkout'
},
entry: () => console.log('Entered cart state'),
exit: () => console.log('Exited cart state')
},
checkout: {
on: {
PAYMENT: 'payment',
BACK_TO_CART: 'cart'
},
entry: () => console.log('Entered checkout state')
},
payment: {
on: {
SUCCESS: 'confirmed',
FAILURE: 'payment_failed',
BACK_TO_CHECKOUT: 'checkout'
},
entry: () => console.log('Processing payment...')
},
payment_failed: {
on: {
RETRY: 'payment',
BACK_TO_CHECKOUT: 'checkout'
},
entry: () => console.log('Payment failed!')
},
confirmed: {
on: {
FULFILL: 'shipped'
},
entry: () => console.log('Order confirmed!')
},
shipped: {
on: {
DELIVER: 'delivered'
},
entry: () => console.log('Order shipped!')
},
delivered: {
on: {},
entry: () => console.log('Order delivered!')
}
}
});
// Subskrypcja na zmiany stanu
orderMachine.subscribe((state) => {
console.log(`Current state: ${state}`);
});
// Symulacja przepływu zamówienia
console.log('=== Order Flow Simulation ===');
orderMachine.send('CHECKOUT');
orderMachine.send('PAYMENT');
orderMachine.send('SUCCESS');
orderMachine.send('FULFILL');
orderMachine.send('DELIVER');Zdarzenie niedozwolone w bieżącym stanie, na przykład DELIVER w koszyku, jest ignorowane z ostrzeżeniem, więc nieprawidłowe przejście jest niemożliwe.
Integracja z XState (konceptualna)
XState to popularna biblioteka maszyn stanów. Dokłada kontekst (dane obok stanu), strażników (guards) blokujących przejścia i wywoływanie usług, takich jak płatność:
// Przykład jak wyglądałaby maszyna stanów z XState
// (kod konceptualny - wymaga instalacji XState)
/*
import { createMachine, interpret } from 'xstate';
const orderMachineXState = createMachine({
id: 'order',
initial: 'cart',
context: {
items: [],
total: 0,
customer: null
},
states: {
cart: {
on: {
ADD_ITEM: {
actions: 'addItem'
},
REMOVE_ITEM: {
actions: 'removeItem'
},
CHECKOUT: {
target: 'checkout',
cond: 'hasItems'
}
}
},
checkout: {
entry: 'calculateTotal',
on: {
PAYMENT: 'payment',
BACK_TO_CART: 'cart'
}
},
payment: {
invoke: {
id: 'paymentService',
src: 'processPayment',
onDone: {
target: 'confirmed',
actions: 'savePaymentInfo'
},
onError: {
target: 'payment_failed',
actions: 'savePaymentError'
}
},
on: {
BACK_TO_CHECKOUT: 'checkout'
}
},
payment_failed: {
on: {
RETRY: 'payment',
BACK_TO_CHECKOUT: 'checkout'
}
},
confirmed: {
entry: 'sendConfirmationEmail',
on: {
FULFILL: 'shipped'
}
},
shipped: {
entry: 'sendShippingNotification',
on: {
DELIVER: 'delivered'
}
},
delivered: {
entry: 'sendDeliveryConfirmation',
type: 'final'
}
}
}, {
actions: {
addItem: (context, event) => {
// Dodaj produkt do koszyka
},
removeItem: (context, event) => {
// Usuń item z koszyka
},
calculateTotal: (context) => {
// Oblicz sumę
},
savePaymentInfo: (context, event) => {
// Zapisz info o płatności
}
},
guards: {
hasItems: (context) => context.items.length > 0
},
services: {
processPayment: (context) => {
// Zwraca Promise z procesem płatności
return fetch('/api/payment', {
method: 'POST',
body: JSON.stringify(context)
});
}
}
});
*/Kod jest w komentarzu, bo wymaga instalacji biblioteki, i używa API XState 4. W wersji 5 funkcję interpret zastąpiło createActor, cond nazywa się guard, services to actors, akcje i strażnicy dostają jeden obiekt ({ context, event }), a usługę zwracającą Promise trzeba opakować w fromPromise.
Zaawansowane maszyny stanów z hierarchią
Maszyna może też przechowywać kontekst, jak odtwarzacz muzyki z głośnością i playlistą:
// Hierarchiczna maszyna stanów dla odtwarzacza muzyki
interface PlayerContext {
currentTrack: string | null;
volume: number;
position: number;
playlist: string[];
}
class HierarchicalStateMachine extends StateMachine {
private context: any = {};
constructor(config: MachineConfig, initialContext: any = {}) {
super(config);
this.context = { ...initialContext };
}
getContext(): any {
return { ...this.context };
}
updateContext(updates: any): void {
this.context = { ...this.context, ...updates };
}
}
const musicPlayerMachine = new HierarchicalStateMachine({
id: 'musicPlayer',
initial: 'stopped',
states: {
stopped: {
on: {
PLAY: 'playing',
LOAD: 'loading'
},
entry: () => console.log('Player stopped')
},
loading: {
on: {
LOADED: 'playing',
ERROR: 'error'
},
entry: () => console.log('Loading track...')
},
playing: {
on: {
PAUSE: 'paused',
STOP: 'stopped',
NEXT: 'loading',
PREVIOUS: 'loading'
},
entry: () => console.log('Playing music'),
exit: () => console.log('Stopped playing')
},
paused: {
on: {
PLAY: 'playing',
STOP: 'stopped'
},
entry: () => console.log('Music paused')
},
error: {
on: {
RETRY: 'loading',
STOP: 'stopped'
},
entry: () => console.log('Error loading track')
}
}
}, {
currentTrack: null,
volume: 50,
position: 0,
playlist: ['track1.mp3', 'track2.mp3']
});
// Symulacja odtwarzacza
console.log('=== Music Player Simulation ===');
musicPlayerMachine.send('LOAD');
musicPlayerMachine.send('LOADED');
musicPlayerMachine.send('PAUSE');
musicPlayerMachine.send('PLAY');
musicPlayerMachine.send('NEXT');Nazwa klasy jest na wyrost: to wciąż płaska maszyna rozszerzona o kontekst. Prawdziwa hierarchia oznacza stany zagnieżdżone, na przykład playing z podstanami normal i shuffle, co XState obsługuje natywnie.
Porównanie wzorców zarządzania stanem
Kiedy używać którego wzorca?
W dużej aplikacji wzorce często współpracują, a każdy odpowiada za inny rodzaj stanu:
// Przykład aplikacji używającej wszystkich trzech wzorców
// 1. Flux - do prostego zarządzania stanem UI
class UIStateManager {
// Zarządzanie stanem komponentów UI, formularzy, modali
}
// 2. Event Sourcing - do logiki biznesowej z historią
class OrderEventStore {
// Zarządzanie zamówieniami z pełną historią zmian
}
// 3. State Machines - dla złożonych przepływów
class WorkflowStateMachine extends StateMachine {
// Zarządzanie przepływami biznesowymi (np. procesami akceptacji)
}
// Kombinacja wzorców w jednej aplikacji
class ApplicationStateManager {
private uiState: UIStateManager;
private orderEvents: OrderEventStore;
private workflows: Map<string, WorkflowStateMachine>;
constructor() {
this.uiState = new UIStateManager();
this.orderEvents = new OrderEventStore();
this.workflows = new Map();
}
// Flux dla UI
updateUI(action: Action): void {
// this.uiState.dispatch(action);
}
// Event Sourcing dla zdarzeń biznesowych
processBusinessEvent(event: Event): void {
// this.orderEvents.append(event);
}
// State Machines dla przepływów pracy
advanceWorkflow(workflowId: string, event: string): void {
const workflow = this.workflows.get(workflowId);
if (workflow) {
workflow.send(event);
}
}
}Flux obsługuje stan interfejsu, Event Sourcing dane biznesowe z historią, a maszyny stanów przepływy, takie jak akceptacja zamówienia.
Najlepsze praktyki
Trzy zasady porządkują pracę: rozdziel rodzaje stanu, testuj każdy wzorzec osobno i dbaj o wydajność:
// 1. Separation of Concerns - rozdzielenie odpowiedzialności
interface StatePattern {
// UI State - Flux/Redux
uiState: {
loading: boolean;
errors: string[];
notifications: any[];
};
// Business State - Event Sourcing
businessEvents: Event[];
// Workflow State - State Machines
workflows: Record<string, string>; // workflowId -> currentState
}
// 2. Testowanie wzorców
class StatePatternTests {
testFluxActions(): void {
// Testy action creators, reducerów i store'ów
}
testEventSourcing(): void {
// Testy aplikowania eventów i projektorów
}
testStateMachines(): void {
// Testy przejść stanów, strażników i akcji
}
}
// 3. Wydajność
class PerformanceOptimizations {
// Memoizacja selektorów Flux
memoizedSelectors = new Map();
// Snapshotting dla Event Sourcing
snapshots = new Map();
// Cache instancji maszyn stanów
machineInstances = new Map();
}Memoizacja selektorów oszczędza obliczeń we Fluksie, a snapshoty w Event Sourcing pozwalają odtwarzać stan od ostatniej migawki zamiast od pierwszego eventu.
Podsumowanie wzorców zarządzania stanem
Flux daje prosty jednokierunkowy przepływ, łatwe debugowanie i śledzenie zmian, więc pasuje do stanu UI, choć w prostych aplikacjach bywa przerostem formy. Event Sourcing daje pełną historię, odtworzenie stanu z dowolnego momentu i naturalny audyt, kosztem złożoności i miejsca na dysku. Maszyny stanów jasno modelują złożone przepływy, wykluczają nieprawidłowe stany i łatwo je wizualizować oraz testować, choć wymagają nauki i bywają przesadą dla prostych stanów.
Moja rekomendacja: w małej aplikacji wystarczy podstawowy stan (useState, signals), w średniej Flux/Redux dla UI, w dużej kombinacja wzorców, a w systemach klasy enterprise Event Sourcing i maszyny stanów dla krytycznych procesów. W edytorze poniżej zbudujesz system bezpieczeństwa parku, a w kolejnej lekcji zajmiemy się code splittingiem i tree shakingiem.
Pamiętaj: stan parku to jego pamięć, więc zmieniaj go tylko przez jedną, dobrze pilnowaną bramę.
Kod do tej lekcji: index.js
// System Bezpieczeństwa Parku
// Ćwiczenie: Zaimplementuj system monitoringu sensorów
class SecuritySystem {
constructor() {
this.sensors = new Map();
this.alerts = [];
this.securityLevel = "GREEN";
}
// Zaimplementuj metody:
// addSensor(zone, type) - dodaj sensor do strefy
// triggerAlert(zone, severity) - wyzwól alert
// getStatus() - zwróć status bezpieczeństwa
addSensor(zone, type) {
// Twój kod tutaj
}
triggerAlert(zone, severity) {
// Twój kod tutaj
}
getStatus() {
// Twój kod tutaj
}
}
const security = new SecuritySystem();
security.addSensor("Sektor A", "motion");
console.log("System bezpieczeństwa aktywny");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. Co oznacza zasada Single Responsibility Principle (SRP)?
2. Co oznacza zasada Open/Closed Principle?
Zadania praktyczne w grze
- Edytor kodu
W pliku index.js jest klasa VisitorManagementSystem, która trzyma odwiedzających w Map pod numerem biletu. Uzupełnij luki: ___BLANK1___ to metoda Map, która zwraca odwiedzającego dla numeru biletu, ___BLANK2___ to metoda tablicy, która z listy odwiedzających buduje jeden obiekt z liczbą osób w każdej strefie (startuje od pustego obiektu {}), a ___BLANK3___ to właściwość Map z liczbą zapisanych odwiedzających. trackVisitorLocation ma zwrócić false dla nieznanego biletu, a getStats() zwrócić { total, byZone }, np. { total: 2, byZone: { entrance: 1, raptors: 1 } }.
- Układanie w pionie
Uporządkuj etapy implementacji wzorca Singleton:
- Edytor kodu
W pliku index.js jest klasa GeneticLaboratory. Uzupełnij luki: ___BLANK1___ to metoda wyrażenia regularnego, która sprawdza, czy napis pasuje do wzorca (sekwencja zawiera tylko litery A, C, G i T), i zwraca true albo false, ___BLANK2___ to pole wyniku analyzeDNA, które mówi, czy DNA jest poprawne, a ___BLANK3___ to wyrażenie, które zwraca nową tablicę ze wszystkimi gatunkami zapisanymi w Map this.species. analyzeDNA ma zwrócić { valid, length, gcContent }, synthesize nie może utworzyć gatunku z niepoprawnego DNA (zwraca wtedy null), a getSpeciesDatabase zwraca tablicę gatunków.