Modelul Chain of Responsibility în TypeScript

Ce este

Modelul Chain of Responsibility trimite o cerere de-a lungul unui lanț de handlere. Fiecare handler fie se ocupă de cerere, fie o predă următorului. Expeditorul cunoaște doar prima verigă — niciodată pe cel care o va rezolva de fapt.

Exemplu: o linie de suport

O problemă intră la botul de chat. Ce nu poate rezolva botul ajunge la suportul tehnic; ce nu poate rezolva suportul tehnic ajunge la manager, care se ocupă de tot ce primește.

Veriga next are tipul Handler | undefined, așa că ultima verigă pur și simplu nu are una. this.next?.handle(problem) o apelează doar când există.

Trimite mai departe până când cineva poate

fără internet parcurge un pas și se oprește la suportul tehnic; cererea de rambursare parcurge tot lanțul până la manager. Apelantul a scris aceeași singură linie de ambele dăți.

Scrie un program TypeScript cu un Chain of Responsibility: o clasă Handler cu un nume, o funcție canFix și un handler next opțional. Construiește un lanț de suport format din bot de chat, suport tehnic și manager (care rezolvă tot). Trimite o problemă pe care o poate rezolva veriga din mijloc și una care ajunge până la manager, afișând fiecare pas.

> Ieșire: program TypeScript și rezultatul capturat

Prompt

Scrie un program TypeScript cu un Chain of Responsibility: o clasă Handler cu un nume, o funcție canFix și un handler next opțional. Construiește un lanț de suport format din bot de chat, suport tehnic și manager (care rezolvă tot). Trimite o problemă pe care o poate rezolva veriga din mijloc și una care ajunge până la manager, afișând fiecare pas.

Ieșire: program TypeScript și rezultatul capturat

class Handler {
  private name: string
  private canFix: (problem: string) => boolean
  private next: Handler | undefined

  constructor(name: string, canFix: (problem: string) => boolean,
              next?: Handler) {
    this.name = name
    this.canFix = canFix
    this.next = next
  }

  handle(problem: string): void {
    if (this.canFix(problem)) {
      console.log(this.name, "a rezolvat:", problem)
      return
    }
    console.log(this.name, "trimite mai departe")
    this.next?.handle(problem)
  }
}

const manager = new Handler("manager", () => true)
const tech = new Handler("suport tehnic", (p) => p === "fără internet", manager)
const bot = new Handler("bot de chat", (p) => p === "parolă uitată", tech)

bot.handle("fără internet")
console.log("---")
bot.handle("cerere de rambursare")

Când să îl folosești

Folosește-l când mai multe părți ar putea trata o cerere și nu se știe dinainte care este cea potrivită — escaladare la suport, middleware, tratarea evenimentelor, fluxuri de aprobare.

Evită-l când handlerul este mereu cunoscut — apelează-l direct. Un lanț cu o singură verigă, sau unul care se termină mereu la aceeași verigă, este un simplu apel de funcție deghizat.

Avantaje și dezavantaje

Avantaje: expeditorul și receptorii sunt decuplați; verigile pot fi adăugate, eliminate și reordonate liber; fiecare handler rămâne mic.

Dezavantaje: nu există garanția că cineva tratează cererea — un lanț rupt o înghite în tăcere; urmărirea unei cereri prin multe verigi face depanarea mai lentă.