Modelul State în TypeScript

Ce este

Șablonul State oferă unui obiect un comportament diferit în stări diferite, transformând fiecare stare în propria clasă. Obiectul păstrează starea sa curentă și îi deleagă sarcinile; trecerea la o altă stare înseamnă înlocuirea valorii.

Astfel se elimină switch (status) { ... }, care crește tot mai mult și se repetă în jumătate din metode, fiind înlocuit cu o clasă mică pentru fiecare stare.

Exemplu: viața unei comenzi

O comandă este nouă, apoi plătită, apoi expediată. Fiecare clasă de stare răspunde la describe() în felul ei și știe ce stare urmează — comanda în sine nu conține deloc logică legată de status.

Fiecare stare este o clasă

advance() rămâne o singură linie pentru totdeauna, iar cele trei linii afișate provin din trei clase diferite. Adăugarea unei stări „livrată” înseamnă o clasă nouă plus o modificare în next() — niciun switch de căutat.

Scrie un program TypeScript cu șablonul State: o interfață OrderState cu next și describe, clasele de stare NewOrder, Paid și Shipped (starea Shipped rămâne Shipped) și o clasă Order care păstrează o stare, având o metodă advance ce o înlocuiește. Parcurge o comandă prin toate cele trei stări, afișând fiecare descriere.

> Ieșire: program TypeScript și rezultatul capturat

Prompt

Scrie un program TypeScript cu șablonul State: o interfață OrderState cu next și describe, clasele de stare NewOrder, Paid și Shipped (starea Shipped rămâne Shipped) și o clasă Order care păstrează o stare, având o metodă advance ce o înlocuiește. Parcurge o comandă prin toate cele trei stări, afișând fiecare descriere.

Ieșire: program TypeScript și rezultatul capturat

interface OrderState {
  next(): OrderState
  describe(): string
}

class NewOrder implements OrderState {
  next(): OrderState {
    return new Paid()
  }

  describe(): string {
    return "nouă - așteaptă plata"
  }
}

class Paid implements OrderState {
  next(): OrderState {
    return new Shipped()
  }

  describe(): string {
    return "plătită - se împachetează coletul"
  }
}

class Shipped implements OrderState {
  next(): OrderState {
    return this
  }

  describe(): string {
    return "expediată - este pe drum"
  }
}

class Order {
  state: OrderState = new NewOrder()

  advance(): void {
    this.state = this.state.next()
  }
}

const order = new Order()

console.log(order.state.describe())
order.advance()
console.log(order.state.describe())
order.advance()
console.log(order.state.describe())

Când să îl folosești

Folosește-l când comportamentul unui obiect chiar diferă în funcție de stare, iar stările au reguli reale privind tranzițiile — comenzi, documente (ciornă/în verificare/publicat), conexiuni, personaje de joc.

Renunță la el când un status este doar afișat și nu schimbă niciodată comportamentul. O reuniune de tipuri șir precum "new" | "paid" | "shipped" cu un singur switch este suficientă sub trei stări cu reguli simple.

Avantaje și dezavantaje

Avantaje: regulile fiecărei stări stau într-o singură clasă mică; tranzițiile imposibile pur și simplu nu sunt scrise; stările noi extind în loc să modifice.

Dezavantaje: multe clase minuscule pentru mecanisme simple; fluxul întregului mecanism este împrăștiat prin fișiere — o diagramă într-un comentariu ajută.