Menene Decorator pattern?

Question

Accepted Answer

**Decorator** pattern yana ƙara **jeri ko ayyuka** ga abubuwa ta hanyar nannade su — ba tare da canja wurin original class ba. Yana ba da flexible madadin subclassing don fadada aiki, yana ba ka damar tsara jeri.

## Menene Decorator pattern take

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

## Misali

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

## Amfani da bukatuwa

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

## Me ya sa ya mahalaci

Ganin Decorator pattern yana da mahimmanci saboda yana da **mahimman tsarin jeri** don flexible fadada jeri, saboda haka yana da mahimmanci hankalin ƙira.

Decorator pattern yana ƙara jeri ga abubuwa ta hanyar **nannade su** (tare da same interface, mikawa zuwa original tare da ƙara jeri), ba tare da canja wurin original class ba — yana ba da flexible madadin subclassing.

Ganin menene take (nannade abun don ƙara jeri, tare da damar **tsara decorators** don haɗa jeri da dama) shine mahimmin ilimi.

Ganin **amfani** yana da mahimmanci: yana ƙara jeri **ba tare da canja wurin original** (bin open/closed principle) da guje **subclass explosion** da zai fito daga yin subclasses ga kowane haɗa siffa, yana ba ka damar **tsara jeri flexible a lokaci** (tsara decorator da daban-daban ta hanyoyi daban-daban), kuma yana goyan bayan single responsibility (kowane decorator yana ƙara ɗaya).

Wannan composition — gina jeri ta tsara decorators ƙanƙanta, masu locus — shine mahimmin ƙarfin tsarin, flexibility da ya wuce subclassing.

Ganin **amfani** — I/O streams (misalin classic na nannade streams), middleware (nannade request handlers — gida a web frameworks), UI components, ƙara cross-cutting aiki (logging, caching, validation) kewaye da core object, da React's higher-order components — yana bayyana bada farko jiya.

Decorator pattern yana bayyana a cikin real frameworks da libraries.

Saboda Decorator pattern yana mahimmin tsarin jeri don flexible fadada jeri (nannade don ƙara jeri ba tare da canja wurin originals ko subclass explosion, tsara jeri a lokaci), kuma saboda ganin menene take, amfani, da amfani gida (streams, middleware, features) yana da mahimmanci ta aiki, ganin Decorator pattern yana da mahimmanci, commonly-applicable design ilimi — useful tsarin don flexible, composable jeri fadada, bayyana a cikin real frameworks (streams, middleware, HOCs), kuma mahimmin design ilimi don fadada aiki jingina ba tare da canja wurin originals ko yin rigid subclass hierarchies ba.