Guide Amical sur les Ensembles JavaScript : Votre Guide pour des Données Organisées

Salut à toi, futurs magiciens JavaScript ! Aujourd'hui, nous allons entreprendre un voyage passionnant à la découverte du monde des Ensembles JavaScript. Ne t'inquiète pas si tu es nouveau dans le programme - je serai ton guide fiable, et nous explorerons ce sujet pas à pas. À la fin de ce tutoriel, tu manipuleras les Ensembles comme un pro !

JavaScript - Sets

Qu'est-ce qu'un Ensemble ?

Avant de plonger dans le code, parlons de ce qu'est réellement un Ensemble. Imagine que tu as un sac de billes, mais ce sac est spécial - il n'autorise qu'une bille de chaque couleur. C'est essentiellement ce qu'est un Ensemble en JavaScript : une collection qui ne peut contenir que des valeurs uniques. Pas de doublons autorisés !

Syntaxe : Créer un Ensemble

Commençons par les bases. Voici comment tu crées un nouveau Ensemble :

let mon Ensemble = new Set();

C'est tout ! Tu viens de créer un Ensemble vide. Mais que faire si tu veux créer un Ensemble avec quelques valeurs initiales ? Pas de problème :

let ensembleFruits = new Set(['apple', 'banana', 'orange']);

Maintenant, tu as un Ensemble avec trois fruits. Souviens-toi, même si tu essaies d'ajouter un autre 'apple', il ne sera pas inclus parce que les Ensembles ne conservent que des valeurs uniques.

Paramètres : Que Peux-tu Mettre dans un Ensemble ?

Les Ensembles en JavaScript sont plutôt flexibles. Tu peux ajouter divers types de valeurs :

Nombres
Chaînes
Objets
Tableaux
Même d'autres Ensembles !

Voyons un exemple :

let ensembleMélange = new Set([1, 'two', {three: 3}, [4, 5]]);
console.log(ensembleMélange);

Si tu exécutes ce code, tu verras que notre Ensemble contient tous ces types de valeurs différents.

Exemples : Jouer avec les Ensembles

Maintenant que nous connaissons les bases, jouons un peu avec les Ensembles !

Ajouter et Supprimer des Éléments

let ensembleCouleurs = new Set();

// Ajouter des éléments
ensembleCouleurs.add('rouge');
ensembleCouleurs.add('bleu');
ensembleCouleurs.add('vert');

console.log(ensembleCouleurs); // Output: Set(3) { 'rouge', 'bleu', 'vert' }

// Essayer d'ajouter un doublon
ensembleCouleurs.add('rouge');
console.log(ensembleCouleurs); // Output: Set(3) { 'rouge', 'bleu', 'vert' }

// Supprimer un élément
ensembleCouleurs.delete('bleu');
console.log(ensembleCouleurs); // Output: Set(2) { 'rouge', 'vert' }

Comme tu peux le voir, lorsque nous avons essayé d'ajouter 'rouge' à nouveau, l'Ensemble est resté inchangé. C'est la beauté des Ensembles - ils gèrent automatiquement les doublons pour nous !

Vérifier la Présence d'Éléments

Tu veux savoir si un Ensemble contient une valeur spécifique ? Utilise la méthode has() :

let ensembleAnimaux = new Set(['chien', 'chat', 'oiseau']);

console.log(ensembleAnimaux.has('chien')); // Output: true
console.log(ensembleAnimaux.has('poisson')); // Output: false

Taille d'un Ensemble

Pour découvrir combien d'éléments uniques sont dans ton Ensemble, utilise la propriété size :

let ensembleNombres = new Set([1, 2, 3, 4, 5, 5, 5]);
console.log(ensembleNombres.size); // Output: 5

Même si nous avons ajouté trois 5, l'Ensemble ne les compte qu'une fois !

Opérations Mathématiques sur les Ensembles

Maintenant, mettons nos chapeaux de mathématicien et regardons quelques opérations que nous pouvons effectuer avec les Ensembles.

Union

Une union combine deux Ensembles, en conservant tous les éléments uniques des deux :

let ensemble1 = new Set([1, 2, 3]);
let ensemble2 = new Set([3, 4, 5]);

let ensembleUnion = new Set([...ensemble1, ...ensemble2]);
console.log(ensembleUnion); // Output: Set(5) { 1, 2, 3, 4, 5 }

Intersection

Une intersection ne conserve que les éléments qui existent dans les deux Ensembles :

let ensemble1 = new Set([1, 2, 3, 4]);
let ensemble2 = new Set([3, 4, 5, 6]);

let ensembleIntersection = new Set([...ensemble1].filter(x => ensemble2.has(x)));
console.log(ensembleIntersection); // Output: Set(2) { 3, 4 }

Différence

Une différence conserve les éléments de l' Ensemble 1 qui ne sont pas dans l' Ensemble 2 :

let ensemble1 = new Set([1, 2, 3, 4]);
let ensemble2 = new Set([3, 4, 5, 6]);

let ensembleDifference = new Set([...ensemble1].filter(x => !ensemble2.has(x)));
console.log(ensembleDifference); // Output: Set(2) { 1, 2 }

Référence des Ensembles JavaScript

Voici un tableau pratique de toutes les méthodes et propriétés que nous avons discutées, plus quelques-unes de plus :

Méthode/Propriété	Description
`new Set()`	Crée un nouveau Ensemble
`add(value)`	Ajoute un nouvel élément à l'Ensemble
`delete(value)`	Supprime un élément de l'Ensemble
`has(value)`	Retourne true si la valeur existe dans l'Ensemble
`clear()`	Supprime tous les éléments de l'Ensemble
`size`	Retourne le nombre d'éléments dans l'Ensemble
`forEach(callback)`	Appelle une fonction pour chaque élément dans l'Ensemble
`values()`	Retourne un itérateur avec toutes les valeurs dans l'Ensemble
`keys()`	Identique à values()
`entries()`	Retourne un itérateur avec les paires [valeur, valeur] de l'Ensemble

Et voilà, les amis ! Vous venez de terminer votre cours accéléré sur les Ensembles JavaScript. Souvenez-vous, les Ensembles sont comme ces amis qui gardent toujours les choses uniques et organisées - ils sont géniaux à avoir autour lorsque vous traitez des données sans doublons.

Pratiquez la création et la manipulation des Ensembles, et bientôt vous les utiliserez naturellement dans vos aventures de codage. Qui sait ? Peut-être que vous commencerez même à voir des Ensembles partout - comme dans ce tiroir à chaussettes où aucune paire n'est la même !

Continuez à coder, restez curieux, et souvenez-vous : dans le monde des Ensembles, être unique est le nom du jeu !

Credits: Image by storyset