Decorators என்றால் என்ன மற்றும் அவை எவ்வாறு பயன்படுத்தப்படுகின்றன?

Question

Accepted Answer

**Decorator** என்பது ஒரு சிறப்பு அறிவிப்பு (`@name`) ஆகும், இது வகுப்பு, முறை, சொத்து அல்லது அளவுருவிற்கு நடத்தை அல்லது metadata ஐச் சேர்க்கிறது. இது runtime ஆல் decorated target உடன் அழைக்கப்படும் ஒரு செயல்பாடு ஆகும், இது உங்களை அதை declaratively wrap அல்லது annotate செய்ய அனுமதிக்கிறது.

```ts
// A simple method decorator that logs calls
function log(target: any, key: string, desc: PropertyDescriptor) {
  const original = desc.value;
  desc.value = function (...args: any[]) {     // wrap the original method
    console.log(`calling ${key} with`, args);
    return original.apply(this, args);
  };
}

class Service {
  @log
  fetch(id: number) { return { id }; }
}
new Service().fetch(1); // logs "calling fetch with [1]" then runs
```

Decorator முறை descriptor ஐ பெற்று அதை wrapper உடன் மாற்றியது — method body ஐ தொடாமல் cross-cutting behavior (logging, caching, timing).

## நீங்கள் அவற்றை அதிகம் பார்க்கும் இடம்: frameworks

```ts
@Controller("users")          // NestJS — declares a route controller
export class UsersController {
  @Get(":id")                 // maps GET /users/:id
  findOne(@Param("id") id: string) { return id; } // param decorator injects the route param
}

@Entity()                     // TypeORM — maps a class to a DB table
class User { @Column() name: string; }
```

NestJS, Angular, TypeORM, மற்றும் class-validator ஆகியவை DI, routing, ORM mapping, மற்றும் validation க்கான decorators ஐ சுற்றி கட்டப்பட்டுள்ளன.

## இரண்டு வகைகள் (முக்கியம்)

```json
{ "experimentalDecorators": true, "emitDecoratorMetadata": true }
```

மேலே உள்ள **legacy (experimental)** decorators ஆகியவை Nest/Angular/TypeORM இன்று நம்பியுள்ளன. **TC39 Stage-3 decorators** (TS 5+) என்ற புதிய வடிவமும் உள்ளது, இது வேறு கையொப்பத்துடன் உள்ளது, இது ஆகாய நிலைமான — ஆனால் பெரும்பாலான বিদ்যமான frameworks இன்னும் legacy வடிவத்தைப் பயன்படுத்துகின்றன.

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

Decorators깔끔한, declarative meta-programming ஐ இயக்குகின்றன — server frameworks மற்றும் ORM களின் முதுகெலும்பு.

மechanismஐ (target ஐ wrap செய்யும் ஒரு function) மற்றும் legacy-vs-standard பிளவை இரண்டையும் அறிந்திருப்பது NestJS/Angular ecosystem ல் வேலை செய்ய அத்தியாவசியம்.