Formations — 1 037 leçons en français

Accueil › TypeScript › Paramètres et valeur de retour

Paramètres et valeur de retour

Typer les fonctionsdebutant

Une fonction a deux faces, et TypeScript ne les traite pas pareil. Les paramètres se déclarent ; le retour se déduit.

function totalHT(lignes: { prix: number; quantite: number }[]) {
  return lignes.reduce((somme, l) => somme + l.prix * l.quantite, 0);
}
// totalHT : (lignes: { prix: number; quantite: number; }[]) => number

Le retour number n'est écrit nulle part. Il est calculé depuis les return du corps. Omettre un paramètre, en revanche, ne pardonne pas sous strict :

function premier(xs) {
  //           ^ TS7006: Parameter 'xs' implicitly has an 'any' type.
  return xs[0];
}

Cette asymétrie a une raison. Les paramètres sont ce que l'appelant promet : personne ne peut le déduire. Le retour est ce que le corps produit : il est déjà écrit, en toutes lettres, dans l'implémentation.

Annoter le retour reste une décision de conception

export function totalHT(lignes: Ligne[]): number {
  if (lignes.length === 0) return;
  //                       ^ erreur ici : `undefined` n'est pas un `number`
  return lignes.reduce((s, l) => s + l.prix * l.quantite, 0);
}

Sans le : number, ce return nu n'est pas une erreur : il élargit simplement le retour à number | undefined. L'erreur réapparaît alors chez chaque appelant, sous la forme TS18048: 'total' is possibly 'undefined' — parfois dans un autre fichier, parfois dans un autre paquet.

L'annotation ne remplace pas l'inférence. Elle inverse son sens : le compilateur ne décrit plus l'implémentation, il la juge.

Les termes à connaître

Annotation de paramètre

Le type écrit après le nom du paramètre. Sous strict, il est obligatoire quand rien ne permet de le déduire du contexte, sans quoi noImplicitAny signale TS7006.

Inférence du retour

TypeScript calcule le type de retour à partir des return du corps. Il n'y a donc jamais d'obligation de l'écrire — seulement des raisons de le faire.

Retour annoté

Un contrat vérifié dans le sens inverse de l'inférence. Le compilateur ne décrit plus l'implémentation, il la contrôle.

void

« La valeur de retour ne sera pas utilisée. » Une fonction typée () => void a le droit de renvoyer quelque chose — ce quelque chose est simplement ignoré par le type.

never

Le type d'une fonction qui ne rend jamais la main — elle lève une erreur ou boucle indéfiniment. Il permet à l'analyse de flux de marquer la suite comme inatteignable.

Typage contextuel

L'inférence qui descend de l'attendu vers l'écrit. Le paramètre d'une fonction passée à map n'a pas besoin d'annotation parce que map dit déjà son type.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.