Module 4 -- Méthodes des Collections : L'Art de Tordre les Données

let témoins = ["Kowalski", "Novak"];

// push/pop - à la FIN
témoins.push("Schmidt");  // ["Kowalski", "Novak", "Schmidt"]
let dernier = témoins.pop(); // "Schmidt", retour à ["Kowalski", "Novak"]

// unshift/shift - au DÉBUT
témoins.unshift("Miller"); // ["Miller", "Kowalski", "Novak"]
let premier = témoins.shift(); // "Miller", retour à ["Kowalski", "Novak"]

// splice - Le scalpel (modifie sur place)
témoins.splice(1, 0, "Jones"); // À l'index 1, coupe 0, insère "Jones"
// devient ["Kowalski", "Jones", "Novak"]

témoins.splice(0, 1); // À l'index 0, coupe 1
// devient ["Jones", "Novak"]

témoins.splice(1, 1, "Smith", "Williams"); // Remplace "Novak" par deux noms
// devient ["Jones", "Smith", "Williams"]

let chiffres = [1, 2, 3, 4, 5];

// map - Transforme chaque élément (crée un NOUVEAU tableau)
let carrés = chiffres.map(n => n * n);
console.log(carrés); // [1, 4, 9, 16, 25]

let noms = ["marlowe", "spade"];
let majuscules = noms.map(nom => nom.toUpperCase());
console.log(majuscules); // ["MARLOWE", "SPADE"]

// filter - Filtre selon une condition (nouveau tableau)
let pairs = chiffres.filter(n => n % 2 === 0);
console.log(pairs); // [2, 4]

let suspectsLongs = noms.filter(nom => nom.length > 6);
console.log(suspectsLongs); // ["marlowe"]

// reduce - Réduit à une valeur unique (la plus lourde)
let somme = chiffres.reduce((total, n) => total + n, 0);
console.log(somme); // 15

// reduceRight - Même chose, de droite à gauche

let dossiers = [
  {id: 1, nom: "Rocco"},
  {id: 2, nom: "Vito"},
  {id: 3, nom: "Rocco"}
];

// find - Trouve le premier qui correspond
let rocco = dossiers.find(dossier => dossier.nom === "Rocco");
console.log(rocco); // {id: 1, nom: "Rocco"}

// findIndex - Trouve son index
let index = dossiers.findIndex(dossier => dossier.nom === "Vito");
console.log(index); // 1

// indexOf/lastIndexOf - Pour les valeurs simples
let marques = ["Chevrolet", "Ford", "Cadillac", "Chevrolet"];
console.log(marques.indexOf("Chevrolet"));     // 0 (premier)
console.log(marques.lastIndexOf("Chevrolet")); // 3 (dernier)

// includes - Vérifie la présence
console.log(marques.includes("Ford")); // true
console.log(marques.includes("Chrysler")); // false

let cotes = [85, 92, 78];

// forEach - Juste parcourir (plus propre qu'un for)
cotes.forEach((cote, index) => {
  console.log(`Cote ${index}: ${cote}`);
});

// every - Tous les éléments passent le test ?
let tousValides = cotes.every(cote => cote > 0);
console.log(tousValides); // true

// some - Au moins un passe ?
let aÉchoué = cotes.some(cote => cote < 60);
console.log(aÉchoué); // false

// slice - Extrait une tranche (NE MODIFIE PAS l'original)
let preuves = ["A", "B", "C", "D", "E"];
let extrait = preuves.slice(1, 4); // Index 1 à 4 (exclu)
console.log(extrait); // ["B", "C", "D"]
console.log(preuves); // ["A", "B", "C", "D", "E"] (intact)

// concat - Fusionne
let gangEst = ["Moretti"];
let gangOuest = ["Rosetti"];
let tous = gangEst.concat(gangOuest, ["le Parrain"]);
console.log(tous); // ["Moretti", "Rosetti", "le Parrain"]

// join - Transforme en chaîne
let mots = ["Tu", "parles", "trop"];
console.log(mots.join(" ")); // "Tu parles trop"
console.log(mots.join("-")); // "Tu-parles-trop"

// reverse - Inverse l'ordre (MODIFIE l'original)
let ordre = ["entrée", "action", "fuite"];
ordre.reverse();
console.log(ordre); // ["fuite", "action", "entrée"]

// sort - Trie (MODIFIE l'original, piège avec les nombres)
let villes = ["Detroit", "Atlantic City", "Boston"];
villes.sort();
console.log(villes); // ["Atlantic City", "Boston", "Detroit"]

let codes = [10, 1, 5, 100];
codes.sort(); // Mauvais ! Trie comme des strings
console.log(codes); // [1, 10, 100, 5] (Le 5 à la fin, bug classique)

codes.sort((a, b) => a - b); // Bon ! Compare comme nombres
console.log(codes); // [1, 5, 10, 100]

// flat - Aplatit les tableaux imbriqués
let stratagème = [1, [2, 3], [4, [5, 6]]];
console.log(stratagème.flat());    // [1, 2, 3, 4, [5, 6]]
console.log(stratagème.flat(2));   // [1, 2, 3, 4, 5, 6] (2 niveaux)

// flatMap - map() puis flat(1)
let phrases = ["laisse tomber", "fais gaffe"];
let mots = phrases.flatMap(phrase => phrase.split(" "));
console.log(mots); // ["laisse", "tomber", "fais", "gaffe"]

// fill - Remplit avec une valeur
let coups = new Array(5).fill(0);
console.log(coups); // [0, 0, 0, 0, 0]

coups.fill(7, 1, 3); // Remplit avec 7 de l'index 1 à 3 (exclu)
console.log(coups); // [0, 7, 7, 0, 0]

// from - Crée un tableau à partir d'un itérable
let set = new Set([1, 2, 3]);
let tableau = Array.from(set);
console.log(tableau); // [1, 2, 3]

// Tableau de 5 éléments calculés
let progression = Array.from({length: 5}, (_, i) => i * 10);
console.log(progression); // [0, 10, 20, 30, 40]

// of - Crée un tableau à partir des arguments
Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]

let ensemble = new Set();

// Ajout
ensemble.add(1);
ensemble.add(2);
ensemble.add(1); // Doublon, ignoré.
ensemble.add("code secret");
ensemble.add({empreinte: "X7B"});

console.log(ensemble.size); // 4

// Vérification
console.log(ensemble.has(1)); // true
console.log(ensemble.has(3)); // false

// Suppression
ensemble.delete(2);
console.log(ensemble.has(2)); // false

// Parcours
ensemble.forEach(valeur => console.log(valeur));

// Convertir en tableau
let liste = Array.from(ensemble);
// ou
let liste2 = [...ensemble];

// Usage : éliminer les doublons
let témoignages = ["A", "B", "B", "C", "C"];
let uniques = [...new Set(témoignages)];
console.log(uniques); // ["A", "B", "C"]

let carte = new Map();

// set/get (pas de point .)
carte.set("nom de code", "Faucon");
carte.set("niveau", 7);
carte.set(404, "Non trouvé"); // La clé peut être un nombre.
carte.set({dossier: "noir"}, "Classifié");

console.log(carte.get("nom de code")); // "Faucon"
console.log(carte.get(404));     // "Non trouvé"
console.log(carte.size);       // 4

// Vérifier/supprimer
console.log(carte.has("niveau")); // true
carte.delete("niveau");
console.log(carte.has("niveau")); // false

// Parcours
for (let [clé, valeur] de carte) {
  console.log(`${clé}: ${valeur}`);
}

// Méthodes utiles
console.log([...carte.keys()]);   // Clés
console.log([...carte.values()]); // Valeurs
console.log([...carte.entries()]); // Paires

// Objet classique
let indic = {pseudo: "Souris"};
indic.contact = "Midi";

// Map
let carte = new Map();
carte.set("pseudo", "Souris");

// POURQUOI Map ?
// 1. Clés de n'importe quel type (objet, fonction...)
// 2. L'ordre d'insertion est gardé.
// 3. .size existe direct.
// 4. Plus rapide pour ajouter/supprimer souvent.

// POURQUOI l'Objet ?
// 1. Plus simple : obj.prop vs map.get("prop")
// 2. JSON natif.
// 3. Pour les cas simples.

let cible = {
  nom: "Vargas",
  métier: "portier",
  ville: "Miami"
};

// Obtenir clés/valeurs/entrées
console.log(Object.keys(cible));   // ["nom", "métier", "ville"]
console.log(Object.values(cible)); // ["Vargas", "portier", "Miami"]
console.log(Object.entries(cible)); // [["nom", "Vargas"], ["métier", "portier"], ["ville", "Miami"]]

// Parcourir
for (let [clé, valeur] of Object.entries(cible)) {
  console.log(`${clé}: ${valeur}`);
}

// assign - Fusionner (ancienne méthode)
let défaut = {risque: "faible", statut: "surveillance"};
let fiche = Object.assign({}, défaut, {risque: "élevé"});
console.log(fiche); // {risque: "élevé", statut: "surveillance"}

// ES6+ : le spread operator est souvent plus clair
let fiche2 = {...défaut, risque: "élevé"};

let véhicule = {
  plaque: "XYZ-789",
  année: 1978,
  démarrer() {
    return "Le moteur grogne.";
  }
};

// hasOwnProperty - La propriété est-elle DIRECTE sur l'objet ?
console.log(véhicule.hasOwnProperty("plaque")); // true
console.log(véhicule.hasOwnProperty("toString")); // false (hérité)

// toString - Représentation chaîne (à redéfinir)
console.log(véhicule.toString()); // "[object Object]"

// Redéfinition
véhicule.toString = function() {
  return `${this.plaque} (${this.année})`;
};
console.log(véhicule.toString()); // "XYZ-789 (1978)"