Come si annotano variabili, parametri e tipi di ritorno?

Question

Accepted Answer

Aggiungere un tipo dopo i due punti. TypeScript può **inferire** molti tipi, quindi si annota dove aggiunge chiarezza o dove l'inferenza non è possibile.

```ts
// variables — usually let inference work
let count: number = 0;     // explicit
let name = "Ann";          // inferred as string (annotation redundant)

// function parameters — always annotate (can't be inferred)
function greet(name: string, times: number): string {
  return name.repeat(times);
}

// arrays and objects
const ids: number[] = [1, 2, 3];
const user: { name: string; age: number } = { name: "Ann", age: 30 };
```

## Tipi di ritorno: inferire o annotare?

```ts
function add(a: number, b: number) { return a + b; } // inferred return: number
function load(): Promise<User> { ... }                // explicit — documents the contract
```

I tipi di ritorno vengono inferiti, ma annotarli su funzioni esportate/pubbliche è una buona pratica: documenta l'intento e cattura gli errori *all'interno* della funzione (se accidentalmente si restituisce la cosa sbagliata, l'errore punta alla funzione, non ai suoi chiamanti).

## Casi speciali

```ts
function log(msg: string): void {}     // returns nothing
function fail(): never { throw new Error(); } // never returns normally
const fn: (x: number) => string = ...; // function type annotation
```

## Perché è importante

La regola generale: **annota in modo esplicito le firme delle funzioni (parametri e tipi di ritorno pubblici), lascia che le variabili locali vengano inferite.** Questo mantiene il codice conciso mentre rende i contratti ai confini delle funzioni chiari e verificati.