Bonjour, cher héros du code ! 🦸‍♀️🦸‍♂️
Aujourd’hui, je vais te révéler le super-pouvoir caché de JavaScript : l’objet Set. Il peut ressembler à un Array, mais c’est un champion pour les éléments uniques uniquement ! 🏆

Dans cet article, tu trouveras des informations de base, des astuces pratiques et des exemples créatifs. Allons-y ! 💖

1️⃣ Qu’est-ce qu’un Set ? (Et pourquoi tu ne devrais pas tomber amoureux 😏)

Imagine que tu as une collection, mais tu veux une seule fois chaque élément.
C’est exactement ce que fait un Set. Il ressemble à un Array mais ne stocke pas les doublons.

const fruits = new Set();
fruits.add("pomme");
fruits.add("poire");
fruits.add("pomme"); // 😂 Ceci ne sera pas ajouté, les Sets n’aiment pas les doublons
console.log(fruits); // Set(2) { 'pomme', 'poire' }

Explication :

• new Set() crée un Set vide.
• add() ajoute des valeurs au Set.
• Les Sets n’autorisent jamais les doublons, donc la deuxième “pomme” n’est pas ajoutée.

💡 Astuce : Si tu veux supprimer les doublons, tu peux convertir un Array en Set puis revenir à un Array. Un mini super-pouvoir en JS 😎.

2️⃣ Méthodes de Base des Sets : Les Super-Armes du Set 🛡️

Voici les principales méthodes pour gérer un Set :

1. add(value) – La Magie de l’Ajout ✨

const fruits = new Set();
fruits.add("pomme");
fruits.add("poire");
fruits.add("banane");

console.log(fruits); // Set(3) { 'pomme', 'poire', 'banane' }

Explication :

• add() ajoute une valeur au Set.
• Si la valeur existe déjà, le Set l’ignore.
• Pense au Set comme un ami fidèle : “Pas de doublons autorisés !” 😏

💡 Astuce : Pour nettoyer une liste soumise par un utilisateur, new Set(liste) supprime instantanément les doublons.

2. delete(value) – Allez, dehors ! ✋

fruits.delete("poire");
console.log(fruits); // Set(2) { 'pomme', 'banane' }

Explication :

• delete() supprime la valeur spécifiée du Set.
• Si la valeur n’est pas dans le Set, rien ne se passe.

💡 Astuce : delete() retourne un booléen. Tu peux vérifier si la suppression a réussi :

console.log(fruits.delete("pomme")); // true
console.log(fruits.delete("poire")); // false

3. has(value) – Mode Détective 🕵️

console.log(fruits.has("pomme")); // true
console.log(fruits.has("poire")); // false

Explication :

• has() vérifie si une valeur existe dans le Set.
• Comme un agent secret : “Cette valeur est-elle ici ?” 😎

💡 Astuce : Combine has() + add() pour empêcher les utilisateurs d’ajouter des doublons :

const amis = new Set();
function ajouterAmi(nom) {
    if (!amis.has(nom)) {
        amis.add(nom);
        console.log(`${nom} ajouté ! 🎉`);
    } else {
        console.log(`${nom} existe déjà, pas de doublons ! 😏`);
    }
}
ajouterAmi("Ahmet");
ajouterAmi("Ahmet");

4. clear() – Le Bouton Reset 🔥

fruits.clear();
console.log(fruits); // Set(0) {}

Explication :

• clear() vide complètement le Set.
• Toutes les valeurs disparaissent, comme de vieux souvenirs 😂

5. size – La Taille du Set 📏

const nombres = new Set([1,2,3,3,4]);
console.log(nombres.size); // 4

Explication :

• size indique le nombre d’éléments dans le Set.
• Comme length pour un Array.

💡 Astuce : Utilise size pour limiter rapidement les doublons. Par exemple, empêcher plus de 5 ajouts.

3️⃣ Utiliser les Sets plus Intelligemment : Astuces Magiques ✨

Array → Set : Supprimer les doublons !

const nums = [1,2,2,3,3,3];
const uniqueNums = new Set(nums);
console.log(uniqueNums); // Set(3) { 1, 2, 3 }

Explication :

• Les doublons dans l’Array sont automatiquement supprimés.

💡 Astuce : Si ta base de données renvoie des listes désordonnées, les Sets peuvent sauver la situation !

Set → Array : Rester Flexible !

const uniqueArray = [...uniqueNums];
console.log(uniqueArray); // [1, 2, 3]

Explication :

• Utilise l’opérateur spread (...) pour convertir un Set en Array.
• Cela te permet de continuer à utiliser les méthodes d’Array.

4️⃣ Mini-Jeu : Liste d’Amis 🥳

Imagine une application où les utilisateurs ajoutent des amis, mais tu ne veux pas de doublons.
Le Set est ton héros ici :

const amis = new Set();

amis.add("Ahmet");
amis.add("Ayşe");
amis.add("Ahmet"); // doublons ignorés

for (let ami of amis) {
  console.log(ami); // Ahmet, Ayşe
}

💖 Le Set est fidèle : pas de doublons 😏

5️⃣ Bonus : Boucles et Astuces pour les Sets 🌀

Parcourir un Set est facile :

amis.forEach(ami => console.log(`Ami : ${ami}`));

Explication :

• Utilise forEach ou for...of pour itérer sur les éléments d’un Set.
• Contrairement aux Maps, les Sets ne stockent que des valeurs, pas de paires clé-valeur.

💡 Astuce : Tu peux aussi faire des “maths de sets” comme intersections et différences :

const setA = new Set([1,2,3,4]);
const setB = new Set([3,4,5,6]);

// Intersection
const intersection = new Set([...setA].filter(x => setB.has(x)));
console.log(intersection); // Set(2) {3, 4}

// Différence
const difference = new Set([...setA].filter(x => !setB.has(x)));
console.log(difference); // Set(2) {1, 2}

🎉 Résumé

• Set = Collection sans doublons 💎
• add() = Ajouter un élément
• delete() = Supprimer un élément
• has() = Vérifier l’existence
• clear() = Tout supprimer
• size = Nombre d’éléments

💡 Astuces Bonus :

• Array → Set = supprimer les doublons
• Set → Array = utiliser les méthodes d’Array
• Intersection & Différence = faire des maths de sets