Wat is het Decorator-patroon?

Question

Accepted Answer

Het **Decorator**-patroon voegt dynamisch **gedrag of verantwoordelijkheden** toe aan objecten door deze in te pakken — zonder de originele klasse aan te passen. Het biedt een flexibel alternatief voor subclassing om functionaliteit uit te breiden, waardoor je gedragingen kunt samenstellen.

## Wat het Decorator-patroon doet

```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
```

## Voorbeeld

```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
```

## Voordelen en toepassingen

```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
```

## Waarom het belangrijk is

Het begrijpen van het Decorator-patroon is waardevol omdat het een **nuttig structureel patroon** is voor het flexibel uitbreiden van gedrag, dus het is praktisch relevante ontwerpkennis.

Het Decorator-patroon voegt gedrag toe aan objecten door deze **in te pakken** (dezelfde interface behoudend, delegerend naar het origineel terwijl gedrag wordt toegevoegd), zonder de originele klasse aan te passen — wat een flexibel alternatief voor subclassing biedt.

Begrijpen wat het doet (een object inpakken om gedrag toe te voegen, met de mogelijkheid om **decorators te stapelen** om meerdere gedragingen samen te stellen) is de kernkennis.

De **voordelen** begrijpen is essentieel: het voegt gedrag toe **zonder het origineel aan te passen** (volgens het open/closed-principe) en voorkomt de **subclass-explosie** die zou ontstaan door subclasses te maken voor elke combinatie van features, het laat je **gedragingen flexibel tijdens runtime samenstellen** (verschillende decorators in verschillende combinaties stapelen), en het ondersteunt single responsibility (elke decorator voegt één ding toe).

Deze samenstellingsbaarheid — gedrag opbouwen door kleine, gefocuste decorators te stapelen — is de kernsterkte van het patroon, veel flexibler dan rigide subclassing.

De **toepassingen** begrijpen — I/O-streams (het klassieke voorbeeld van streams inpakken), middleware (request handlers inpakken — veel voorkomend in webframeworks), UI-componenten, cross-cutting features toevoegen (logging, caching, validatie) rond een kerneobject, en React's higher-order components — maakt de brede praktische toepasbaarheid duidelijk.

Het Decorator-patroon verschijnt in hele echte frameworks en bibliotheken.

Omdat het Decorator-patroon een nuttig structureel patroon is voor het flexibel uitbreiden van gedrag (inpakken om gedrag toe te voegen zonder originelen aan te passen of subclass-explosie, gedragingen tijdens runtime samenstellen), en omdat begrijpen wat het doet, de voordelen en de veel voorkomende toepassingen (streams, middleware, features) praktisch relevant zijn, is het begrijpen van het Decorator-patroon waardevol, algemeen toepasbaar ontwerpkennis — een nuttig patroon voor flexibele, samenstellingbare gedragsuitbreiding, verschijnt in echte frameworks (streams, middleware, HOCs), en is belangrijke ontwerpkennis voor het schoon uitbreiden van functionaliteit zonder originelen aan te passen of rigide subclass-hiërarchieën te creëren.