Comment annotez-vous les variables, les paramètres et les types de retour ?

Question

Accepted Answer

Vous ajoutez un type après un deux-points. TypeScript peut **déduire** de nombreux types, donc vous annotez là où cela ajoute de la clarté ou où l'inférence n'est pas possible.

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

## Types de retour : inférer ou annoter ?

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

Les types de retour sont déduits, mais les annoter sur les fonctions exportées/publiques est une bonne pratique : cela documente l'intention et détecte les erreurs *à l'intérieur* de la fonction (si vous retournez accidentellement la mauvaise chose, l'erreur pointe sur la fonction, pas sur ses appelants).

## Cas particuliers

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

## Pourquoi c'est important

Règle empirique : **annotez explicitement les signatures de fonction (paramètres et types de retour publics), laissez les variables locales être déduites.** Cela garde le code concis tout en rendant les contrats aux limites des fonctions clairs et vérifiés.