რა არის Decorator pattern?

Question

Accepted Answer

**Decorator** pattern დინამიურად დაამატებს **ქცევას ან პასუხისმგებლობას** ობიექტებს მათი გახვევით — ორიგინალური კლასის შეცვლის გარეშე. ის უზრუნველყოფს მოქნილ ალტერნატივას სუბკლასირების ნაცვლად ფუნქციონალობის გაფართოებისთვის, რაც საშუალებას გაძლევთ ქცევების კომპოზიცია.

## რა აკეთებს Decorator pattern

```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 pattern-ის გაცნობიერება მূল্যবადია, რადგან ის არის **სასარგებლო სტრუქტურული pattern** ქცევის მოქნილად გაფართოებისთვის, ამიტომ ეს პრაქტიკულად რელევანტური დიზაინის ცოდნაა.

Decorator pattern დაამატებს ქცევას ობიექტებს **მათი გახვევით** (იგივე ინტერფეისის შენარჩუნებით, ორიგინალთან დელეგირებით, აქვს დამატებული ქცევა), ორიგინალური კლასის შეცვლის გარეშე — უზრუნველყოფს მოქნილ ალტერნატივას სუბკლასირების ნაცვლად.

ის გაგება, რა აკეთებს (ობიექტის გახვევა ქცევის დამატების მიზნით, **decorator-ების დაწყობის** უნარით მრავალი ქცევის კომპოზიციისთვის) არის ძირითადი ცოდნა.

**უპირატესობების** გაცნობიერება მნიშვნელოვანია: ის დაამატებს ქცევას **ორიგინალის შეცვლის გარეშე** (შენდა/დახურვის პრინციპის დაცვით) და თავს აურიდებს **სუბკლასის აფეთქებას**, რომელიც გაჩნდებოდა თითოეული ფიჩერის კომბინაციისთვის სუბკლასების შექმნით, ის საშუალებას გაძლევთ **ქცევების მოქნილი კომპოზიცია რান-ტაიმზე** (სხვადსხვა decorator-ების დაწყობა სხვადსხვა კომბინაციებში), და ის უჭერს ერთი პასუხისმგებლობის პრინციპს (თითოეული decorator ერთ რამეს დაამატებს).

ეს კომპოზიციურობა — ქცევის აგება მცირე, ფოკუსირებული decorator-ების დაწყობით — არის ამ pattern-ის მთავარი სიძლიერე, ბევრად უფრო მოქნილი, ვიდრე მკაცრი სუბკლასირება.

**გამოყენების** გაცნობიერება — I/O ნაკადები (კლასიკური მაგალითი ნაკადების გახვევის), მიდლვერი (მოთხოვნის დამაკავშირებელი გახვევა — გავრცელებული ვებ-ფრეიმვორკებში), UI კომპონენტები, ჯვარედინი ფიჩერების (logging, caching, validation) დამატება ძირითადი ობიექტის გარშემო, და React-ის უფრო მაღალი ოდენის კომპონენტები — განმარტავს მის ფართო რეალური სამყაროს გამოყენებას.

Decorator pattern გვხვდება რეალური ფრეიმვორკებითა და ბიბლიოთეკებში.

ვინაიდან Decorator pattern არის სასარგებლო სტრუქტურული pattern ქცევის მოქნილად გაფართოებისთვის (გახვევა ქცევის დამატების მიზნით ორიგინალის შეცვლის ან სუბკლასის აფეთქების გარეშე, ქცევების კომპოზიცია რან-ტაიმზე), და ვინაიდან მისი გაგება, რა აკეთებს, მისი უპირატესობები, და მისი გავრცელებული გამოყენება (ნაკადები, მიდლვერი, ფიჩერები) პრაქტიკულად რელევანტურია, Decorator pattern-ის გაცნობიერება მূল్్ყბადია, ხშირად გამოყენებული დიზაინის ცოდნა — სასარგებლო pattern მოქნილი, კომპოზიციური ქცევის გაფართოებისთვის, რომელიც გვხვდება რეალური ფრეიმვორკებში (ნაკადები, მიდლვერი, HOC-ები), და მნიშვნელოვანი დიზაინის ცოდნა ფუნქციონალობის გაფართოებისთვის ნათლად ორიგინალის შეცვლის ან მკაცრი სუბკლასის იერარქიის შექმნის გარეშე.