Fonctions en TypeScript

Introduction aux Fonctions

Dans le monde de TypeScript, les fonctions ne sont pas seules : elles sont accompagnées de leurs types de paramètres et de leurs valeurs de retour. Comprendre comment ces éléments interagissent est essentiel pour tirer le meilleur parti de ce langage.

Les Paramètres de Fonction

Les types des paramètres de la fonction sont similaires aux déclarations de variables. Si un paramètre a une valeur par défaut, il héritera du type correspondant. Sinon, on peut explicitement déclarer le type de ce paramètre en ajoutant une annotation de type après son nom. Par exemple, dans la fonction logAgeAndName(), l'âge est spécifiquement défini comme un number, alors que le nom est déduit comme étant un string à partir de sa valeur par défaut :

function logAgeAndName(age: number, name = '(anonyme)') {  console.log(`${name}, âge ${age}`);}
logAgeAndName(16, 'Mulan'); // ok: Mulan, âge 16
logAgeAndName(0); // aussi ok: (anonyme), âge 0
logAgeAndName('Mulan', 16); // Erreur : Argument de type 'string' non assignable au paramètre de type 'number'

Paramètres Optionnels

On peut rendre les paramètres d'une fonction optionnels en ajoutant un ? après leur nom, avant toute annotation de type. TypeScript comprendra alors qu'ils n'ont pas besoin d'être fournis lors de l'appel de la fonction. La valeur par défaut sera alors définie sur undefined. Ainsi, dans la fonction logFavoriteNumberAndReason(), favorite est un paramètre obligatoire de type number, tandis que reason est un paramètre optionnel de type string :

function logFavoriteNumberAndReason(favorite: number, reason?: string) {  console.log(`Favori : ${favorite}!`);
  if (reason) {    console.log(`Parce que : ${reason}!`);  }}
logFavoriteNumberAndReason(7, 'un référence à un jeu vidéo ésotérique'); // Ok
logFavoriteNumberAndReason(9001); // Ok
logFavoriteNumberAndReason(); // Erreur : Attendu 1-2 arguments, mais 0 fournis.

Types de Retour

La plupart des fonctions sont écrites de façon à ce que TypeScript puisse déduire la valeur qu'elles retournent en analysant toutes les instructions de retour. Les fonctions sans valeur de retour ont un type de retour void. Prenons par exemple la fonction getRandomFriend(), qui est inférée comme retournant un type string :

function getRandomFriend(fallback: string) {  switch (Math.floor(Math.random() * 5)) {    case 0:      return 'Josh';    case 1:      return 'Sara';    case 2:      return 'Sonny';    default:      return fallback;  }}
const friend = getRandomFriend('Codey'); // Type : string

Types de Fonction

Les types de fonction peuvent être représentés dans le système de type. Ils ressemblent à une fonction fléchée mais incluent le type de retour à la place du corps de la fonction. Par exemple, withIncrementedValue() prend un paramètre fonction receiveNewValue qui accepte un number et ne renvoie rien (void) :

let value = 0;
function withIncrementedValue(receiveNewValue: (newValue: number) => void) {  value += 1;  receiveNewValue(value);}
withIncrementedValue((receivedValue) => {  console.log('Reçu', receivedValue);});

Conclusion

La maîtrise des fonctions en TypeScript est fondamentale pour créer des applications robustes et maintenables. En comprenant les paramètres, types de retour et l'inférence de types, vous serez bien équipé pour écrire du code de qualité.