TypeScript - Fonctions : Un Guide Pour Les Débutants

Bonjour, aspirants programmeurs ! Aujourd'hui, nous allons entreprendre un voyage passionnant à travers le monde des fonctions TypeScript. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code auparavant - je serai votre guide amical, et nous avancerons pas à pas. À la fin de ce tutoriel, vous serez étonné de ce que vous pouvez faire avec les fonctions en TypeScript !

Qu'est-ce Qu'une Fonction ?

Avant de plonger dans les détails, comprenons ce qu'est une fonction. Pensez à une fonction comme à une recette réutilisable.Tout comme vous suivez une recette pour cuire un gâteau, une fonction est un ensemble d'instructions qui effectue une tâche spécifique dans votre programme.

Voici une fonction simple en TypeScript :

function greet(name: string): string {
return `Bonjour, ${name} !`;
}

console.log(greet("Alice")); // Output: Bonjour, Alice !

Dans cet exemple, greet est notre fonction. Elle prend un name en entrée et renvoie un message de salutation. Le : string après le paramètre et après les parenthèses indique que la fonction prend une chaîne de caractères en entrée et renvoie une chaîne de caractères.

Paramètres Optionnels

Parfois, vous pourriez vouloir rendre un paramètre optionnel. En TypeScript, vous pouvez le faire en ajoutant un ? après le nom du paramètre.

function introduce(name: string, age?: number): string {
if (age) {
return `Salut, je suis ${name} et j'ai ${age} ans.`;
} else {
return `Salut, je suis ${name}.`;
}
}

console.log(introduce("Bob")); // Output: Salut, je suis Bob.
console.log(introduce("Charlie", 30)); // Output: Salut, je suis Charlie et j'ai 30 ans.

Dans cette fonction, age est optionnel. Si il est fourni, nous l'incluons dans la présentation ; sinon, nous l'ignorons.

Paramètres Rest

Les paramètres rest vous permettent de travailler avec plusieurs paramètres sous forme d'un tableau. C'est comme dire : "Je ne sais pas combien d'ingrédients vous me donnerez, mais j'utiliserai tous dans ma recette !"

function makeShake(...fruits: string[]): string {
return `J'ai fait un smoothie avec ${fruits.join(", ")}.`;
}

console.log(makeShake("banane")); // Output: J'ai fait un smoothie avec banane.
console.log(makeShake("fraise", "mangue", "kiwi")); // Output: J'ai fait un smoothie avec fraise, mangue, kiwi.

La syntaxe ...fruits indique à TypeScript de prendre tous les arguments fournis et de les placer dans un tableau appelé fruits.

Paramètres par Défaut

Les paramètres par défaut sont comme avoir un plan de secours. Si quelqu'un ne fournit pas une valeur, nous utiliserons une valeur par défaut.

function orderCoffee(size: string = "moyen", type: string = "latte"): string {
return `Vous avez commandé un ${size} ${type}.`;
}

console.log(orderCoffee()); // Output: Vous avez commandé un moyen latte.
console.log(orderCoffee("grand")); // Output: Vous avez commandé un grand latte.
console.log(orderCoffee("petit", "espresso")); // Output: Vous avez commandé un petit espresso.

Si vous ne spécifiez pas une taille ou un type, cela se default à un latte moyen. Très pratique !

Fonctions Anonymes

Les fonctions anonymes sont comme des agents secrets - elles n'ont pas de nom ! Elles sont souvent utilisées lorsque vous avez besoin d'une fonction rapide que vous n'utiliserez qu'une seule fois.

let greet = function(name: string): string {
return `Bonjour, ${name} !`;
};

console.log(greet("David")); // Output: Bonjour, David !

Ici, nous avons affecté une fonction anonyme à la variable greet. Nous pouvons ensuite utiliser greet comme une fonction régulière.

Le Constructeur de Fonction

Le constructeur de fonction est un moyen de créer des fonctions dynamiquement. C'est comme construire un robot qui peut effectuer des tâches en fonction des instructions que vous lui donnez.

let multiply = new Function('a', 'b', 'return a * b');

console.log(multiply(4, 5)); // Output: 20

Dans cet exemple, nous créons une fonction qui multiplie deux nombres. Le dernier argument est toujours le corps de la fonction, et les autres sont les noms des paramètres.

RécurSION et Fonctions TypeScript

La récurSION se produit lorsque une fonction s'appelle elle-même. C'est comme les poupées russes - chaque poupée contient une version plus petite d'elle-même.

function countdown(n: number): void {
if (n <= 0) {
console.log("Décollage !");
} else {
console.log(n);
countdown(n - 1);
}
}

countdown(3);
// Output:
// 3
// 2
// 1
// Décollage !

Cette fonction compte à rebours d'un nombre donné à zéro. Elle continue à s'appeler avec un nombre plus petit jusqu'à ce qu'elle atteigne zéro.

Fonctions Lambda

Les fonctions lambda, également connues sous le nom de fonctions flèches, sont un moyen abrege de writer les fonctions. Elles sont comme les abréviations de texto pour les fonctions !

let add = (a: number, b: number): number => a + b;

console.log(add(3, 4)); // Output: 7

Cette syntaxe compacte est particulièrement utile pour les fonctions courtes et simples.

Variations Syntaxiques

TypeScript offre plusieurs façons de définir les fonctions. Voici un tableau résumant les différentes syntaxes :

Syntaxe	Exemple
Déclaration de Fonction	function greet(name: string): string { returnBonjour, ${name} !; }
Expression de Fonction	let greet = function(name: string): string { returnBonjour, ${name} !; };
Fonction Flèche	let greet = (name: string): string =>Bonjour, ${name} !;
Méthode dans Objet	let obj = { greet(name: string): string { returnBonjour, ${name} !; } };
Fonction Asynchrone	async function fetchData(): Promise<void> { /* ... */ }

Surcharge de Fonctions

Les surcharges de fonctions vous permettent de définir plusieurs signatures de fonction pour une même fonction. C'est comme avoir plusieurs recettes pour le même plat, en fonction des ingrédients que vous avez.

function makeNoise(animal: "chat"): string;
function makeNoise(animal: "chien"): string;
function makeNoise(animal: string): string {
switch(animal) {
case "chat":
return "Miaou";
case "chien":
return "Wouf";
default:
return "Animal inconnu";
}
}

console.log(makeNoise("chat")); // Output: Miaou
console.log(makeNoise("chien")); // Output: Wouf

Cette fonction peut gérer différents types d'animaux et faire le bruit approprié.

Et voilà ! Nous avons couvert beaucoup de terrain aujourd'hui, des fonctions de base aux concepts plus avancés comme la récurSION et les surcharges de fonctions. Souvenez-vous, apprendre à coder est comme apprendre une nouvelle langue - cela nécessite de la pratique et de la patience. N'ayez pas peur d'expérimenter avec ces concepts et de créer vos propres fonctions. Avant de savoir, vous serez en train d'écrire des programmes complexes avec facilité. Bon codage, et à la prochaine leçon !

Credits: Image by storyset