Cosa sono i decoratori e come vengono utilizzati?

Question

Accepted Answer

Un **decoratore** è una dichiarazione speciale (`@name`) che aggiunge comportamento o metadati a una classe, metodo, proprietà o parametro. È una funzione che il runtime chiama con il target decorato, permettendoti di avvolgerlo o annotarlo in modo dichiarativo.

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

Il decoratore ha ricevuto il descrittore del metodo e lo ha sostituito con un wrapper — comportamento trasversale (logging, caching, timing) senza toccare il corpo del metodo.

## Dove li vedi più spesso: framework

```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 e class-validator sono costruiti attorno ai decoratori per DI, routing, mappatura ORM e validazione.

## Due varianti (importante)

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

I **decoratori legacy (sperimentali)** sopra sono quelli su cui Nest/Angular/TypeORM si affidano oggi. C'è anche la versione più recente dei **decoratori TC39 Stage-3** (TS 5+) con una firma diversa, che è lo standard futuro — ma la maggior parte dei framework esistenti utilizza ancora la forma legacy.

## Perché è importante

I decoratori abilitano la meta-programmazione pulita e dichiarativa — il fondamento dei framework server e degli ORM.

Conoscere sia il meccanismo (una funzione che avvolge un target) che la divisione legacy-versus-standard è essenziale per lavorare nell'ecosistema NestJS/Angular.