Ty­peS­cript Functions : dé­fi­ni­tion et exemples

Ty­peS­cript permet de déclarer des types pour les fonctions, les pa­ra­mètres et les valeurs de retour. Cela permet de détecter les erreurs au plus tôt et d’améliorer la qualité du code en vérifiant que les types de données corrects sont utilisés.

Ty­peS­cript Functions : qu’est-ce que c’est ?

Les fonctions Ty­peS­cript (en anglais Ty­peS­cript Functions) sont un composant central du langage de pro­gram­ma­tion Ty­peS­cript. Les fonctions en Ty­peS­cript sont si­mi­laires à celles de Ja­vaS­cript, mais elles possèdent l’avantage sup­plé­men­taire du typage statique. Avec ce concept, les types de données pour les variables, les pa­ra­mètres et les valeurs de retour sont déjà définis dans le code au moment de la con­cep­tion (compile-time) et ne peuvent pas être modifiés pendant l’exécution. Vous réduisez ainsi les erreurs dans votre en­vi­ron­ne­ment de pro­duc­tion.

Une autre ca­rac­té­ris­tique des fonctions Ty­peS­cript est leur flexi­bi­lité. Les fonctions peuvent avoir des valeurs op­tion­nelles et par défaut pour les pa­ra­mètres, ce qui facilite l’adap­ta­tion à dif­fé­rents cas d’uti­li­sa­tion. Parmi les ap­pli­ca­tions possibles, on trouve le trai­te­ment des données, les in­te­rac­tions avec l’interface uti­li­sa­teur, la pro­gram­ma­tion asyn­chrone et bien plus encore. Vous pouvez également définir des sur­charges afin de proposer dif­fé­rentes fonc­tion­na­li­tés basées sur les valeurs d’entrée.

En plus de la dé­cla­ra­tion de fonctions, Ty­peS­cript vous autorise aussi à utiliser des fonctions d’aide, qui ont une écriture plus courte. Elles sont souvent utilisées dans les pratiques de dé­ve­lop­pe­ment Ja­vaS­cript modernes. Les fonctions Ty­peS­cript sont donc un élément clé qui améliore la sécurité et la li­si­bi­lité du code dans les projets Ty­peS­cript, tout en englobant la flexi­bi­lité et l’adap­ta­bi­lité à de multiples exigences.

Ty­peS­cript Functions : syntaxe

La syntaxe des fonctions Ty­peS­cript est similaire à celle des fonctions Ja­vaS­cript, car Ty­peS­cript est un langage superset de Ja­vaS­cript. Le code de la fonction est placé entre accolades { }. La logique pro­pre­ment dite de la fonction y est im­plé­men­tée. Voici la syntaxe générale d’une fonction Ty­peS­cript :

function functionName(parameter1: type, parameter2: type): returnType {
    // Function Code
    return result; // (optional)
}

• function : ce mot-clé marque le début de la dé­cla­ra­tion de la fonction.
• func­tion­Name : il s’agit du nom de la fonction. Vous devriez choisir un nom des­crip­tif, qui reflète la tâche de la fonction.
• parameter1, parameter2 : il s’agit des pa­ra­mètres que la fonction attend. Chaque paramètre est identifié par son nom et le type de données attendu (an­no­ta­tion de type).
• re­turn­Type : c’est le type de données que la fonction renvoie. Vous pouvez également indiquer void si la fonction ne renvoie pas de valeur.
• return result : fa­cul­ta­tif, est utilisé si la fonction doit renvoyer une valeur.

L’appel des Ty­peS­cript Functions se fait en utilisant le nom de la fonction suivi de pa­ren­thèses. Dans les pa­ren­thèses, vous indiquez les arguments (valeurs d’entrée) pour la fonction, si elle attend des pa­ra­mètres.

functionName(argument1, argument2, ...);

Ty­peS­cript Functions : exemples d’uti­li­sa­tion

Les fonctions Ty­peS­cript sont ex­trê­me­ment po­ly­va­lentes et peuvent effectuer des calculs, des opé­ra­tions et des processus complexes dans les ap­pli­ca­tions.

Fonctions anonymes

Les fonctions anonymes en Ty­peS­cript sont des fonctions qui n’ont pas de nom et sont donc passées di­rec­te­ment dans des ex­pres­sions ou comme arguments à d’autres fonctions. Les fonctions anonymes sont avan­ta­geuses lorsque vous n’avez besoin d’une fonction qu’à un seul endroit du code et que vous ne souhaitez pas attribuer un nom de fonction spé­ci­fique.

var greet = function(name) {
    return "Bonjour, " + name + " !";
};
var message = greet("Marie");
console.log(message); // Output: "Bonjour, Marie !"

Dans cet exemple, la fonction anonyme est stockée dans la variable greet et est appelée plus tard pour créer un message d’accueil per­son­na­lisé pour le prénom « Marie ».

Parmi les fonctions anonymes, on trouve également les fonctions lambda, connues sous le nom de fonctions fléchées.

const add = (a: number, b: number) => a + b;
const result = add(3, 5); // Output: 8

Ici, une fonction anonyme qui effectue l’addition de deux nombres est assignée à la variable add et est ensuite appelée.

Pa­ra­mètres par défaut

Les pa­ra­mètres par défaut (en anglais Default Pa­ra­me­ters ou Standard Pa­ra­me­ters) vous per­met­tent de définir des fonctions Ty­peS­cript de manière à ce qu’elles aient des valeurs par défaut pour les pa­ra­mètres. Lorsque la fonction est appelée et qu’aucune valeur n’est passée pour un paramètre, la valeur par défaut est utilisée à la place.

function greet(name: string = "tout le monde") {
    return "Bonjour, " + name + " !";
}
console.log(greet()); // Output: "Bonjour, tout le monde !"
console.log(greet("Marie")); // Output: "Bonjour, Marie !"

Ici, la fonction greet a une valeur par défaut tout le monde pour le paramètre name. Si aucune valeur n’est passée pour name lors d’un appel à la fonction, la valeur par défaut est au­to­ma­ti­que­ment utilisée.

Pa­ra­mètres résiduels

Les pa­ra­mètres résiduels (en anglais Rest Pa­ra­me­ters ou Rest Operators) en Ty­peS­cript vous per­met­tent de ras­sem­bler un nombre indéfini d’arguments sous forme de tableau Ty­peS­cript dans une fonction. Cela vous aide lorsque vous souhaitez écrire des fonctions qui doivent traiter un nombre variable d’arguments.

function sum(...numbers: number[]): number {
    let total = 0;
    for (const num of numbers) {
        total += num;
    }
    return total;
}
console.log(sum(1, 2, 3, 4, 5)); // Output: 15

Dans cet exemple, la fonction sum collecte un nombre quel­conque de nombres comme paramètre résiduel numbers et les ad­di­tionne pour calculer le total. Vous pouvez passer autant de nombres que vous le souhaitez, la fonction les ad­di­tion­nera tous.

Sur­charges

Les fonctions Ty­peS­cript avec des sur­charges (Function Overloads) servent à définir plusieurs dé­cla­ra­tions de fonctions avec les mêmes noms, mais avec des types de pa­ra­mètres ou de retour dif­fé­rents. Cela aide Ty­peS­cript à sé­lec­tion­ner au­to­ma­ti­que­ment la dé­cla­ra­tion de fonction correcte en fonction des arguments passés et à effectuer des vé­ri­fi­ca­tions de type.

function concatenate(a: string, b: string): string;
function concatenate(a: number, b: number): string;
function concatenate(a: any, b: any): string {
    return a.toString() + b.toString();
}
console.log(concatenate("Bonjour, ", "tout le monde")); // Output: "Bonjour, tout le monde"
console.log(concatenate(3, 5)); // Output: "35"

Dans l’exemple ci-dessus, nous avons deux sur­charges de fonction pour concatenate. La première accepte deux chaînes de ca­rac­tères et la seconde deux nombres. L’im­plé­men­ta­tion réelle de la fonction convertit les arguments passés en chaînes de ca­rac­tères et les concatène. Ty­peS­cript choisit au­to­ma­ti­que­ment la surcharge ap­pro­priée en fonction des arguments passés et effectue les vé­ri­fi­ca­tions de type né­ces­saires.

Les sur­charges de fonctions sont par­ti­cu­liè­re­ment adaptées si vous dé­ve­lop­pez une API ou une bi­blio­thèque pour laquelle vous souhaitez vous assurer que l’uti­li­sa­tion de la fonction est simple et sans erreur, in­dé­pen­dam­ment des dif­fé­rents types de pa­ra­mètres pouvant être fournis par les uti­li­sa­teurs.