TypeScript - Ensembles : Un guide pour débutants

Bonjour là-bas, future star du codage ! Aujourd'hui, nous allons plonger dans le merveilleux monde des ensembles de TypeScript. Ne vous inquiétez pas si vous n'avez jamais entendu parler des ensembles auparavant - à la fin de ce tutoriel, vous serez un pro des ensembles ! Alors, prenez votre boisson favorite, installez-vous confortablement, et partons ensemble pour cette aventure passionnante.

Qu'est-ce que les ensembles ?

Avant de rentrer dans les détails, comprenons ce qu'est un ensemble. Imaginez que vous avez une petite boîte où vous pouvez mettre différents types d'items, mais l'astuce, c'est que vous devez remember l'ordre exact de ces items. C'est essentiellement ce qu'est un ensemble en TypeScript - un tableau de longueur fixe où chaque élément peut avoir un type différent, et l'ordre compte.

Syntaxe

Commençons par les bases. Voici comment vous déclarez un ensemble en TypeScript :

let monEnsemble: [string, number, boolean] = ['Bonjour', 42, true];

Dans cet exemple, nous avons créé un ensemble appelé monEnsemble qui contient trois éléments : une chaîne, un nombre et un booléen. L'ordre est important ici - le premier élément doit être une chaîne, le second un nombre, et le troisième un booléen.

Accéder aux valeurs des ensembles

Maintenant que nous avons créé notre ensemble, comment accédons-nous à ses valeurs ? C'est simple ! Nous utilisons la notation d'index, tout comme avec les tableaux. Souvenez-vous, en programmation, nous commençons à compter à partir de 0.

let monEnsemble: [string, number, boolean] = ['Bonjour', 42, true];

console.log(monEnsemble[0]); // Output: 'Bonjour'
console.log(monEnsemble[1]); // Output: 42
console.log(monEnsemble[2]); // Output: true

Dans cet exemple, monEnsemble[0] nous donne le premier élément, monEnsemble[1] le second, et ainsi de suite. C'est comme atteindre dans notre boîte et sortir des items un par un.

Opérations sur les ensembles

Les ensembles supportent de nombreuses opérations similaires aux tableaux. Voici quelques-unes :

1. Longueur

Nous pouvons découvrir combien d'éléments sont dans notre ensemble en utilisant la propriété length :

let monEnsemble: [string, number, boolean] = ['Bonjour', 42, true];
console.log(monEnsemble.length); // Output: 3

2. Push

Nous pouvons ajouter des éléments à la fin de notre ensemble en utilisant la méthode push :

let monEnsemble: [string, number] = ['Bonjour', 42];
monEnsemble.push(true);
console.log(monEnsemble); // Output: ['Bonjour', 42, true]

Cependant, soyez prudent ! Bien que TypeScript permette ceci, cela pourrait entraîner un comportement inattendusince nous changeons la structure de notre ensemble.

3. Pop

Nous pouvons supprimer le dernier élément de notre ensemble en utilisant la méthode pop :

let monEnsemble: [string, number, boolean] = ['Bonjour', 42, true];
monEnsemble.pop();
console.log(monEnsemble); // Output: ['Bonjour', 42]

Encore une fois, utilisez ceci avec précaution, car il change la structure de l'ensemble.

Mise à jour des ensembles

Nous pouvons mettre à jour les valeurs de notre ensemble en affectant de nouvelles valeurs à des indices spécifiques :

let monEnsemble: [string, number] = ['Bonjour', 42];
monEnsemble[0] = 'Salut';
monEnsemble[1] = 100;
console.log(monEnsemble); // Output: ['Salut', 100]

N'oubliez pas, vous devez vous en tenir aux types définis dans l'ensemble. Par exemple, vous ne pouvez pas faire ceci :

let monEnsemble: [string, number] = ['Bonjour', 42];
monEnsemble[0] = 100; //Erreur : Type 'number' n'est pas assignable au type 'string'.

Destructuration d'un ensemble

La déstructuration est une façon élégante de dire "démanteler" les valeurs de notre ensemble en variables distinctes. C'est comme ouvrir notre boîte et étaler tous les items sur une table. Voici comment cela fonctionne :

let monEnsemble: [string, number, boolean] = ['Bonjour', 42, true];
let [salutation, reponse, estIncroyable] = monEnsemble;

console.log(salutation);    // Output: 'Bonjour'
console.log(reponse);       // Output: 42
console.log(estIncroyable); // Output: true

Dans cet exemple, nous avons créé trois nouvelles variables (salutation, reponse, et estIncroyable) et leur avons affecté les valeurs de notre ensemble dans l'ordre.

Paramètres de fonction et types d'ensemble

Les ensembles peuvent être très utiles lors du travail avec des fonctions. disons que nous voulons créer une fonction qui prend le nom et l'âge d'une personne, et renvoie un salut. Nous pourrions utiliser un ensemble pour cela :

function saluerPersonne(personne: [string, number]): string {
const [nom, age] = personne;
return `Bonjour, ${nom} ! Vous avez ${age} ans.`;
}

let personne: [string, number] = ['Alice', 30];
console.log(saluerPersonne(personne)); // Output: "Bonjour, Alice ! Vous avez 30 ans."

Dans cet exemple, notre fonction saluerPersonne attend un ensemble avec une chaîne (le nom) et un nombre (l'âge). Nous utilisons ensuite la déstructuration pour extraire ces valeurs et créer notre salutation.

Méthodes des ensembles

Voici un tableau de quelques méthodes courantes que vous pouvez utiliser avec les ensembles :

Méthode	Description	Exemple
push()	Ajoute un ou plusieurs éléments à la fin de l'ensemble	monEnsemble.push(4)
pop()	Supprime le dernier élément de l'ensemble	monEnsemble.pop()
concat()	Combine deux ou plusieurs ensembles	let nouvelEnsemble = ensemble1.concat(ensemble2)
slice()	Retourne une portion de l'ensemble	let portion = monEnsemble.slice(1, 3)
indexOf()	Retourne le premier index où un élément donné peut être trouvé	let index = monEnsemble.indexOf(42)

Souvenez-vous, bien que ces méthodes fonctionnent avec les ensembles, leur utilisation pourrait changer la structure de votre ensemble, ce qui pourrait entraîner un comportement inattendu dans votre code. Utilisez-les toujours avec précaution !

Et voilà, les amis ! Vous venez de terminer votre cours intensif sur les ensembles de TypeScript. De leur création à l'accès de leurs valeurs, de leur mise à jour à leur utilisation dans les fonctions, vous avez maintenant tous les outils nécessaires pour commencer à travailler avec des ensembles dans vos projets TypeScript.

N'oubliez pas, la pratique rend parfait. Alors n'ayez pas peur d'expérimenter avec les ensembles dans votre propre code. Qui sait ? Vous pourriez juste les trouver être votre nouvelle fonctionnalité TypeScript favorite !

Bonne programmation, et puissent vos ensembles toujours être en ordre !

Credits: Image by storyset