Modelul State în Go

Ce este

Șablonul State îi dă unui obiect comportament diferit în stări diferite, făcând din fiecare stare un tip separat. Obiectul își ține starea curentă și îi deleagă lucrul; trecerea în altă stare înseamnă înlocuirea valorii.

El înlocuiește acel switch status { ... } tot mai mare, repetat în jumătate dintre metode, cu un tip mic pentru fiecare stare.

Exemplu: viața unei comenzi

O comandă este nouă, apoi plătită, apoi expediată. Fiecare tip de stare răspunde la Describe() în felul său și știe care stare urmează — comanda în sine nu conține deloc logică de stare.

Fiecare stare este un tip

Advance() rămâne pentru totdeauna o singură linie. Adăugarea unei stări „livrată” înseamnă un tip nou plus un Next() modificat — niciun switch prin care să scotocești.

Scrie un program Go cu șablonul State: o interfață State cu Next și Describe, tipurile de stare New, Paid și Shipped (starea Shipped rămâne Shipped) și un Order care ține o stare, cu o metodă Advance ce o înlocuiește. Plimbă o comandă prin toate cele trei stări, afișând fiecare descriere.

> Ieșire: program Go și rezultatul capturat

Prompt

Scrie un program Go cu șablonul State: o interfață State cu Next și Describe, tipurile de stare New, Paid și Shipped (starea Shipped rămâne Shipped) și un Order care ține o stare, cu o metodă Advance ce o înlocuiește. Plimbă o comandă prin toate cele trei stări, afișând fiecare descriere.

Ieșire: program Go și rezultatul capturat

package main

import "fmt"

type State interface {
  Next() State
  Describe() string
}

type New struct{}

func (New) Next() State      { return Paid{} }
func (New) Describe() string { return "nouă - se așteaptă plata" }

type Paid struct{}

func (Paid) Next() State      { return Shipped{} }
func (Paid) Describe() string { return "plătită - se împachetează cutia" }

type Shipped struct{}

func (Shipped) Next() State      { return Shipped{} }
func (Shipped) Describe() string { return "expediată - este pe drum" }

type Order struct {
  state State
}

func (o *Order) Advance() {
  o.state = o.state.Next()
}

func main() {
  o := &Order{state: New{}}

  fmt.Println(o.state.Describe())
  o.Advance()
  fmt.Println(o.state.Describe())
  o.Advance()
  fmt.Println(o.state.Describe())
}

Când să îl folosești

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

Sari peste el când o stare este doar afișată și nu schimbă niciodată comportamentul. Un câmp de tip string și un singur switch sunt suficiente sub trei stări cu reguli simple.

Avantaje și dezavantaje

Avantaje: regulile fiecărei stări stau într-un singur tip mic; tranzițiile imposibile pur și simplu nu se scriu; stările noi extind, în loc să modifice.

Dezavantaje: multe tipuri mărunte pentru automate simple; fluxul întregului automat este împrăștiat prin fișiere — o diagramă într-un comentariu ajută.