Hvad er Decorator-mønsteret?

Question

Accepted Answer

**Decorator**-mønsteret tilføjer dynamisk **adfærd eller ansvarsområder** til objekter ved at ombryde dem — uden at ændre den originale klasse. Det giver et fleksibelt alternativ til subklasseophobning til udvidelse af funktionalitet, hvilket lader dig sammensætte adfærd.

## Hvad Decorator-mønsteret gør

```text
DECORATOR → WRAP an object to add behavior, keeping the same interface:
  → the decorator wraps the original, adds its behavior, and delegates to the original
  → you can STACK decorators (wrap a wrapped object) → compose multiple behaviors
  → adds functionality WITHOUT modifying the original class or using subclassing
→ "wrap to extend" — flexible, composable behavior addition
```

## Eksempel

```js
// base object
let coffee = { cost: () => 5, description: () => 'coffee' };
// decorators wrap and add behavior
function withMilk(c) {
  return { cost: () => c.cost() + 1, description: () => c.description() + ' + milk' };
}
function withSugar(c) {
  return { cost: () => c.cost() + 0.5, description: () => c.description() + ' + sugar' };
}
coffee = withSugar(withMilk(coffee));   // stack decorators
coffee.cost();          // 6.5 — composed behavior
```

## Fordele og anvendelser

```text
BENEFITS:
  ✓ Add behavior WITHOUT modifying the original (open/closed) or subclass explosion
  ✓ COMPOSE behaviors flexibly at runtime (stack different decorators in combinations)
  ✓ Single responsibility → each decorator adds one thing
USES → I/O streams (wrapping streams), middleware (wrap request handlers), UI components,
  adding features (logging, caching, validation) around a core object; HOC in React
```

## Hvorfor det betyder noget

Forståelse af Decorator-mønsteret er værdifuld, fordi det er et **brugbart strukturelt mønster** til fleksibel udvidelse af adfærd, så det er praktisk relevant designviden.

Decorator-mønsteret tilføjer adfærd til objekter ved at **ombryde dem** (bevare den samme grænseflade, delegere til originalen mens der tilføjes adfærd), uden at ændre den originale klasse — hvilket giver et fleksibelt alternativ til subklasseophobning.

Forståelse af hvad det gør (ombryde et objekt for at tilføje adfærd, med mulighed for at **stable decorators** for at sammensætte flere adfærd) er kernekendskabet.

Forståelse af **fordelene** er vigtig: det tilføjer adfærd **uden at ændre originalen** (i overensstemmelse med åben/lukket-princippet) og undgår den **subklasseeksplosion**, der ville resultere fra at oprette subklasser for hver kombination af funktioner, det lader dig **sammensætte adfærd fleksibelt på køretid** (stable forskellige decorators i forskellige kombinationer), og det understøtter enkelt ansvar (hver decorator tilføjer én ting).

Denne sammensættelighed — opbygning af adfærd ved at stable små, fokuserede decorators — er mønsterets vigtigste styrke, langt mere fleksibel end stiv subklasseophobning.

Forståelse af **anvendelserne** — I/O-strømme (det klassiske eksempel på ombrydning af strømme), middleware (ombrydning af anmodningshåndterer — almindeligt i webrammeværker), UI-komponenter, tilføjelse af tværsnittede funktioner (logging, caching, validering) omkring et kerneobiekt, og Reacts higher-order components — præciserer dets brede anvendelighed i den virkelige verden.

Decorator-mønsteret optræder i hele rigtige rammeværker og biblioteker.

Da Decorator-mønsteret er et brugbart strukturelt mønster til fleksibel udvidelse af adfærd (ombrydning for at tilføje adfærd uden at ændre originaler eller subklasseeksplosion, sammensætning af adfærd på køretid), og da forståelse af hvad det gør, dets fordele og dets almindelige anvendelser (strømme, middleware, funktioner) er praktisk relevant, er forståelse af Decorator-mønsteret værdifuld, almindeligt anvendelig designviden — et brugbart mønster til fleksibel, sammensætbar adfærdsudvidelse, der optræder i hele rigtige rammeværker (strømme, middleware, HOCs), og vigtig designviden til udvidelse af funktionalitet på en ren måde uden at ændre originaler eller skabe stive subklassehierarkier.