Semaine 2 - Jour 3 | Tableaux

Méthodes de tableaux puissantes

JavaScript offre des méthodes de tableaux très puissantes qui permettent de transformer, filtrer et manipuler des données de manière élégante et efficace.

Ces méthodes sont essentielles pour la programmation moderne JavaScript. Elles remplacent souvent les boucles for traditionnelles et rendent le code plus lisible.

Concept clé : La plupart de ces méthodes prennent une fonction callback en paramètre, qui sera exécutée pour chaque élément du tableau.

1. map() - Transformer

map() crée un nouveau tableau en appliquant une fonction à chaque élément. Utilise-le pour transformer des données.

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

                        // Doubler chaque nombre

                        let doubles = nombres.map(n => n * 2);

                        console.log(doubles); // [2, 4, 6, 8, 10]

                        // Exemple pratique : prix avec TVA

                        let prixHT = [100, 200, 50];

                        let prixTTC = prixHT.map(p => p * 1.20);

                        console.log(prixTTC); // [120, 240, 60]

2. filter() - Filtrer

filter() crée un nouveau tableau avec uniquement les éléments qui passent un test. Retourne true pour garder l'élément, false pour l'exclure.

                        let nombres = [1, 2, 3, 4, 5, 6];

                        // Garder seulement les nombres pairs

                        let pairs = nombres.filter(n => n % 2 === 0);

                        console.log(pairs); // [2, 4, 6]

                        // Exemple : notes supérieures à 10

                        let notes = [8, 12, 15, 9, 18];

                        let admis = notes.filter(n => n >= 10);

                        console.log(admis); // [12, 15, 18]

3. reduce() - Réduire

reduce() réduit un tableau à une seule valeur en appliquant une fonction qui combine les éléments. Très utile pour calculer des sommes, moyennes, etc.

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

                        // Calculer la somme

                        let somme = nombres.reduce((acc, n) => acc + n, 0);

                        console.log(somme); // 15

                        // Calculer le produit

                        let produit = nombres.reduce((acc, n) => acc * n, 1);

                        console.log(produit); // 120

                        // acc = accumulateur, n = nombre actuel

4. Autres méthodes utiles

find() trouve un élément • sort() trie • slice() découpe • join() concatène

                        let nombres = [5, 2, 8, 1, 9];

                        // find() - trouve le premier > 5

                        let trouve = nombres.find(n => n > 5);

                        console.log(trouve); // 8

                        // sort() - trier (modifie l'original !)

                        nombres.sort((a, b) => a - b);

                        console.log(nombres); // [1, 2, 5, 8, 9]

                        // slice() - extraire une partie

                        let extrait = nombres.slice(1, 3);

                        console.log(extrait); // [2, 5]

Exemples pratiques

                    // Traitement de données d'étudiants

                    let notes = [12, 15, 8, 18, 9, 14, 16];

                    // Filtrer les notes >= 10

                    let admis = notes.filter(n => n >= 10);

                    console.log('Notes admis:', admis);

                    // Calculer la moyenne

                    let moyenne = notes.reduce((acc, n) => acc + n, 0) / notes.length;

                    console.log('Moyenne:', moyenne.toFixed(2));

                    // Ajouter 2 points bonus à chaque note

                    let avecBonus = notes.map(n => Math.min(n + 2, 20));

                    console.log('Avec bonus:', avecBonus);

                    // Chaîner plusieurs méthodes

                    let resultat = notes

                      .filter(n => n >= 10) // Garder >= 10

                      .map(n => n * 2) // Doubler

                      .reduce((acc, n) => acc + n, 0); // Sommer

                    console.log('Résultat chaîné:', resultat);

Copiez ces exemples dans la console interactive ci-dessus !