const nombres = [5, 12, 8, 3, 19, 7];

// map / filter / reduce : le trio fondamental de la programmation fonctionnelle en JS
const doubles = nombres.map((n) => n * 2);
const pairs = nombres.filter((n) => n % 2 === 0);
const somme = nombres.reduce((acc, n) => acc + n, 0);
const max = nombres.reduce((acc, n) => Math.max(acc, n), -Infinity);

// Chainage : lisible et performant pour des transformations en pipeline
const resultat = nombres
    .filter((n) => n > 5)
    .map((n) => n * 10)
    .reduce((acc, n) => acc + n, 0);

// find / findIndex / findLast (ES2023) : recherche du premier element correspondant
const premierGrand = nombres.find((n) => n > 10);
const indexPremierGrand = nombres.findIndex((n) => n > 10);
const dernierPetit = nombres.findLast((n) => n < 10);

// some / every : tests booleens sur l'ensemble
console.log(nombres.some((n) => n > 15));       // au moins un element valide
console.log(nombres.every((n) => n > 0));         // tous les elements valident

// sort : ATTENTION, mute le tableau original et trie par defaut en chaines !
const nonTries = [10, 1, 21, 2];
console.log([...nonTries].sort());                 // [1, 10, 2, 21] -- BUG : tri lexicographique !
console.log([...nonTries].sort((a, b) => a - b));    // [1, 2, 10, 21] -- correct : comparateur numerique

// toSorted / toReversed / toSpliced (ES2023) : versions IMMUABLES (ne mutent pas l'original)
const trieSansMutation = nonTries.toSorted((a, b) => a - b);
console.log(nonTries);          // inchange

// flat / flatMap : aplatir des tableaux imbriques
const imbrique = [1, [2, 3], [4, [5, 6]]];
console.log(imbrique.flat());           // [1, 2, 3, 4, [5, 6]] -- profondeur 1 par defaut
console.log(imbrique.flat(Infinity));    // aplatissement complet

const phrases = ["bonjour le monde", "comment vas tu"];
const mots = phrases.flatMap((p) => p.split(" "));   // map + flat en une passe

// Destructuring et spread sur les tableaux
const [premier, deuxieme, ...reste] = nombres;
const fusionne = [...nombres, ...doubles];
const copie = [...nombres];               // copie superficielle

// Array.from : creer un tableau depuis un iterable ou array-like
console.log(Array.from({ length: 5 }, (_, i) => i * i));    // [0, 1, 4, 9, 16]
console.log(Array.from("hello"));                              // ['h','e','l','l','o']
console.log(Array.from(new Set([1, 2, 2, 3])));                 // deduplication

// Array.of vs Array() : piege du constructeur avec un seul argument numerique
console.log(Array(5));           // [ <5 vides> ] -- tableau de longueur 5
console.log(Array.of(5));         // [5] -- tableau contenant l'element 5

// includes vs indexOf : includes gere correctement NaN
console.log([1, NaN, 3].indexOf(NaN));      // -1 -- indexOf utilise ===, ne trouve pas NaN
console.log([1, NaN, 3].includes(NaN));       // true -- includes utilise SameValueZero

// Group by (ES2024, methode Object.groupBy)
const utilisateurs = [
    { nom: "Alice", role: "admin" },
    { nom: "Bob", role: "user" },
    { nom: "Cy", role: "admin" },
];
const parRole = Object.groupBy(utilisateurs, (u) => u.role);
console.log(parRole);   // { admin: [Alice, Cy], user: [Bob] }

// Performance : eviter de muter un tableau pendant qu'on l'itere avec forEach
const items = [1, 2, 3];
// items.forEach((item, i) => items.splice(i, 1));    // comportement imprevisible, a EVITER