Decorator பேட்டர்ன் என்றால் என்ன?

Question

Accepted Answer

**Decorator** பேட்டர்ன் அசল வகுப்பைத் திருத்தாமல், பொருள்களை மூடி வைப்பதன் மூலம் **நடத்தை அல்லது பொறுப்புகளை** ديناميकமாக சேர்க்கிறது — இது செயல்பாடு விரிவுபடுத்த subclassing க்கு ஒரு நমनीய மாற்றாகவும், நடத்தைகளை இணைக்கவும் உங்களுக்கு உதவுகிறது.

## Decorator பேட்டர்ன் என்ன செய்கிறது

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

## உதாரணம்

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

## நன்மைகள் மற்றும் பயன்பாடுகள்

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

## இது ஏன் முக்கியமானது

Decorator பேட்டர்ன் புரிந்துகொள்வது மূல்யவானதாகும், ஏனெனில் இது நடத்தைகளை **நমனீயமாக விரிவுபடுத்துவதற்கான** பயனுள்ள संरचनात்मक பேட்டர்ன் ஆகும், எனவே இது käytännöllisesti அடிப்படையிலான ডিজাইன் அறிவாகும்.

Decorator பேட்டர்ன் **மூடுவதன் மூலம்** பொருள்களுக்கு நடத்தையைச் சேர்க்கிறது (அதே இন்টারফேஸைப் பராமரிக்கும்போது, அசல்லுக்கு பொறுப்பை வழங்கி நடத்தையைச் சேர்க்கிறது), அசல் வகுப்பைத் திருத்தாமல் — subclassing க்கு நமனீய மாற்றாக வழங்குகிறது.

இது என்ன செய்கிறது (ஒரு பொருளை மூடுவதன் மூலம் நடத்தையைச் சேர்க்கிறது, **decorators ஐ அடுக்கி வைக்கக்கூடிய திறனுடன்** பல நடத்தைகளை இணைக்க) என்பதைப் புரிந்துகொள்வது அடிப்படை அறிவாகும்.

**நன்மைகளை** புரிந்துகொள்வது முக்கியமாகும்: இது நடத்தையைச் சேர்க்கிறது **அசல்லைத் திருத்தாமல்** (திறந்த/மூடப்பட்ட கோட்பாட்டைப் பின்பற்றி) மற்றும் ஒவ்வொரு அம்சத்தின் சேர்க்கையின் জন்য subclasses உருவாக்குவதிலிருந்து ஏற்படும் **subclass குழப்பத்தை** தவிர்க்கிறது, இது உங்களுக்கு **பல்வேறு சேர்க்கைகளில் பல்வேறு decorators ஐ அடுக்கி வைத்து நடத்தைகளை இணைக்க** நேரத்தில் உங்களுக்கு அனுமதிக்கிறது, மற்றும் இது ஒற்றை பொறுப்பை ஆதரிக்கிறது (ஒவ்வொரு decorator ஒன்றைச் சேர்க்கிறது).

இந்த composability — சிறிய, கவனம் செலுத்திய decorators ஐ அடுக்கி வைப்பதன் மூலம் நடத்தையை உருவாக்குவது — பேட்டர்নின் முக்கிய வலிமை, விறுவிறுத்த subclassing ஐ விட மிகவும் நமனீயமாகும்.

**பயன்பாடுகளைப் புரிந்துகொள்வது** — I/O streams (streams ஐ மூடுவதற்கான பாரம்பரிய உதாரணம்), middleware (கோரிக்கை கட்டமைப்புகளை மூடுவது — வலை கட்டமைப்புகளில் பொதுவானது), UI উपাদানங்கள், cross-cutting features (logging, caching, validation) ஐ ஒரு மূல பொருளைச் சுற்றி சேர்க்கிறது, மற்றும் React's higher-order components — அதன் பரந்த real-world பொருந்தக்கைத் தெளிவு செய்கிறது.

Decorator பேட்டர்ன் உண்மையான கட்டமைப்புகள் மற்றும் நூலகங்கள் முழுவதும் தோன்றுகிறது.

Decorator பேட்டர்ன் ஒரு பயனுள்ள संरचनात्मक பேட்டர்ன் ஆகும், நடத்தைகளை நமனீயமாக விரிவுபடுத்த (நடத்தையைச் சேர்க்க மூடுவது அசல்களைத் திருத்தாமல் அல்லது subclass குழப்பம் இல்லாமல், பல்வேறு சேர்க்கைகளில் நமனீய composability), மற்றும் Decorator பேட்டர்ன் என்பதை புரிந்துகொள்வது மூல் அறிவாகும், அதன் நன்மைகள், மற்றும் அதன் பொதுவான பயன்பாடுகள் (streams, middleware, features) பொருந்தக்கமாக உள்ளன, Decorator பேட்டர்ன் என்பதை புரிந்துகொள்வது மূல்யவானதாகும், பொதுவாக பொருந்தக்கமான வடிவமைப்பு அறிவு — நমனீய, composable நடத்தை விரிவுபடுத்தக்கான பயனுள்ள பேட்டர்ன், உண்மையான கட்டமைப்புகள் (streams, middleware, HOCs) முழுவதும் தோன்றுகிறது, மற்றும் அசல்களை திருத்தாமல் அல்லது விறுவிறுத்த subclass hierarchies ஐ உருவாக்காமல் செயல்பாடுகளை விரிவுபடுத்துவதற்கு முக்கியமான வடிவமைப்பு அறிவாகும்.