Énoncés des TPs - Structures de Données et Méthodes Modernes (Corrigés et Détaillés)

---

TP 1 : map() - Transformer les données

La méthode map() crée un nouveau tableau en appliquant une fonction à chaque élément.

Syntaxe : tableau.map((element, index, array) => { ... })

---

Exercice 1.1 : Transformations numériques

Énoncé : Créez un tableau nombres = [1, 2, 3, 4, 5] et utilisez map() pour doubler, élever au carré et convertir en euros.

Correction complète :

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

// 1. Doubler chaque nombre
const doubles = nombres.map((n) => n * 2);
console.log(doubles); // [2, 4, 6, 8, 10]

// 2. Élever au carré
const carres = nombres.map((n) => n ** 2);
console.log(carres); // [1, 4, 9, 16, 25]

// 3. Convertir en chaîne avec symbole "€"
const avecEuros = nombres.map((n) => `${n}€`);
console.log(avecEuros); // ["1€", "2€", "3€", "4€", "5€"]

Détails :

• n * 2 : multiplication simple
• n ** 2 : opérateur d’exponentiation (équivalent à Math.pow(n, 2))
• Template literals (backticks) : permet d’insérer des variables dans une chaîne

---

Exercice 1.2 : Transformation d’objets (utilisateurs)

Énoncé : Travaillez avec un tableau d’objets utilisateurs.

Correction complète :

const utilisateurs = [
    { nom: 'Alice', age: 25 },
    { nom: 'Bob', age: 30 },
];

// 1. Extraire seulement les noms
const noms = utilisateurs.map((u) => u.nom);
console.log(noms); // ["Alice", "Bob"]

// 2. Créer des phrases descriptives
const phrases = utilisateurs.map((u) => `${u.nom} a ${u.age} ans`);
console.log(phrases);
// ["Alice a 25 ans", "Bob a 30 ans"]

// 3. Ajouter une propriété 'adulte' (age >= 18)
const utilisateursAvecAdulte = utilisateurs.map((u) => ({
    ...u,
    adulte: u.age >= 18,
}));
console.log(utilisateursAvecAdulte);
// [
//   { nom: 'Alice', age: 25, adulte: true },
//   { nom: 'Bob', age: 30, adulte: true }
// ]

Détails importants :

• Spread operator (...u) : copie toutes les propriétés de l’objet
• Les parenthèses autour de ({...}) sont obligatoires pour retourner un objet en arrow function
• Sans parenthèses, les accolades sont interprétées comme le corps de la fonction

✅ Oui, c’est la meilleure approche !

// Ajouter une propriété 'adulte' (age >= 18)
const utilisateursAvecAdulte = utilisateurs.map((user) => ({
    ...user,
    adulte: user.age >= 18,
}));
console.log(utilisateursAvecAdulte);

---

Pourquoi c’est excellent :

1️⃣ Concis et lisible

• Une seule ligne de logique
• Facile à comprendre immédiatement

2️⃣ Approche fonctionnelle

• map() : transforme chaque élément
• Retourne un nouveau tableau
• Ne modifie pas l’original

3️⃣ Spread operator ...user

• Copie toutes les propriétés existantes
• Ajoute la nouvelle propriété adulte
• Crée un nouvel objet (immutable)

4️⃣ Immutabilité

console.log(utilisateurs); // Inchangé ✅
console.log(utilisateursAvecAdulte); // Nouveau tableau ✅

---

Exemple complet :

const utilisateurs = [
    { nom: 'Alice', age: 25 },
    { nom: 'Bob', age: 17 },
    { nom: 'Charlie', age: 35 },
];

// ✅ MEILLEURE APPROCHE
const utilisateursAvecAdulte = utilisateurs.map((user) => ({
    ...user,
    adulte: user.age >= 18,
}));

console.log(utilisateursAvecAdulte);
// [
//   { nom: 'Alice', age: 25, adulte: true },
//   { nom: 'Bob', age: 17, adulte: false },
//   { nom: 'Charlie', age: 35, adulte: true }
// ]

---

Cas d’usage similaires :

// Ajouter plusieurs propriétés
const utilisateursComplets = utilisateurs.map((user) => ({
    ...user,
    adulte: user.age >= 18,
    categorie: user.age < 13 ? 'enfant' : user.age < 18 ? 'ado' : 'adulte',
    id: Math.random(),
}));

// Modifier et ajouter
const utilisateursMaj = utilisateurs.map((user) => ({
    ...user,
    nom: user.nom.toUpperCase(),
    adulte: user.age >= 18,
}));

// Ajouter conditionnellement
const utilisateursFiltrés = utilisateurs.map((user) => ({
    ...user,
    adulte: user.age >= 18,
    ...(user.age >= 18 && { statut: 'majeur' }),
}));

---

⭐ Résumé

C’est la meilleure pratique en JavaScript moderne car :

• ✅ Fonctionnel et déclaratif
• ✅ Immutable (ne modifie pas l’original)
• ✅ Concis et lisible
• ✅ Performant
• ✅ Facile à chaîner avec d’autres méthodes

Continuez avec cette approche ! 🚀

Exercice 1.3 : Conversion de devises

Énoncé : Convertissez des prix en dollars en euros (multiplier par 0.92) et ajouter le symbole “€”.

Correction complète :

const prixEnDollars = [10, 25, 50, 100, 200];

// Conversion dollars → euros avec symbole
const prixEnEuros = prixEnDollars.map((prix) => {
    const enEuros = prix * 0.92;
    return `${enEuros.toFixed(2)}€`;
});

console.log(prixEnEuros);
// ["9.20€", "23.00€", "46.00€", "92.00€", "184.00€"]

// Version compacte (une ligne)
const prixEnEurosCompact = prixEnDollars.map((p) => `${(p * 0.92).toFixed(2)}€`);
console.log(prixEnEurosCompact);

Détails :

• .toFixed(2) : arrondit à 2 décimales et retourne une chaîne
• Utile pour les opérations monétaires

---

TP 2 : filter() - Sélectionner les données

La méthode filter() crée un nouveau tableau contenant seulement les éléments qui satisfont une condition.

Syntaxe : tableau.filter((element, index, array) => condition)

Important : La fonction doit retourner true ou false

---

Exercice 2.1 : Filtrage numérique

Énoncé : Avec nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], filtrez selon différents critères.

Correction complète :

const nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 1. Garder seulement les nombres pairs
const pairs = nombres.filter((n) => n % 2 === 0);
console.log(pairs); // [2, 4, 6, 8, 10]

// 2. Garder seulement les nombres > 5
const superieursCinq = nombres.filter((n) => n > 5);
console.log(superieursCinq); // [6, 7, 8, 9, 10]

// 3. Garder seulement les nombres entre 3 et 7 (inclus)
const entre3et7 = nombres.filter((n) => n >= 3 && n <= 7);
console.log(entre3et7); // [3, 4, 5, 6, 7]

Détails :

• n % 2 === 0 : modulo 2 égal 0 = nombre pair
• && : opérateur ET logique (les deux conditions doivent être vraies)

---

Exercice 2.2 : Filtrage d’objets (utilisateurs)

Énoncé : Filtrez un tableau d’utilisateurs selon différents critères.

Correction complète :

const utilisateurs = [
    { nom: 'Alice', age: 25, ville: 'Paris' },
    { nom: 'Bob', age: 17, ville: 'Lyon' },
    { nom: 'Charlie', age: 35, ville: 'Paris' },
];

// 1. Garder seulement les majeurs (age >= 18)
const majeurs = utilisateurs.filter((u) => u.age >= 18);
console.log(majeurs);
// [
//   { nom: 'Alice', age: 25, ville: 'Paris' },
//   { nom: 'Charlie', age: 35, ville: 'Paris' }
// ]

// 2. Garder seulement les habitants de Paris
const parisiens = utilisateurs.filter((u) => u.ville === 'Paris');
console.log(parisiens);
// [
//   { nom: 'Alice', age: 25, ville: 'Paris' },
//   { nom: 'Charlie', age: 35, ville: 'Paris' }
// ]

// 3. Garder les majeurs de Paris (condition composée)
const majeursDeParis = utilisateurs.filter((u) => u.age >= 18 && u.ville === 'Paris');
console.log(majeursDeParis);
// [
//   { nom: 'Alice', age: 25, ville: 'Paris' },
//   { nom: 'Charlie', age: 35, ville: 'Paris' }
// ]

Détails :

• u.ville === 'Paris' : comparaison de chaînes (stricte avec ===)
• Combinaison de conditions avec && (ET) ou || (OU)

---

Exercice 2.3 : Filtrage de produits

Énoncé : Filtrez un tableau de produits selon le stock et le prix.

Correction complète :

const produits = [
    { nom: 'Laptop', prix: 1200, stock: 5 },
    { nom: 'Souris', prix: 25, stock: 0 },
    { nom: 'Clavier', prix: 85, stock: 12 },
    { nom: 'Écran', prix: 350, stock: 3 },
    { nom: 'Câble USB', prix: 8, stock: 50 },
];

// 1. Produits en stock (stock > 0)
const enStock = produits.filter((p) => p.stock > 0);
console.log(enStock);
// Retourne tous sauf "Souris"

// 2. Produits moins chers que 100€
const moinsCher100 = produits.filter((p) => p.prix < 100);
console.log(moinsCher100);
// [
//   { nom: 'Souris', prix: 25, stock: 0 },
//   { nom: 'Clavier', prix: 85, stock: 12 },
//   { nom: 'Câble USB', prix: 8, stock: 50 }
// ]

// 3. Produits chers (>= 100€) ET en stock
const chersEnStock = produits.filter((p) => p.prix >= 100 && p.stock > 0);
console.log(chersEnStock);
// [
//   { nom: 'Laptop', prix: 1200, stock: 5 },
//   { nom: 'Écran', prix: 350, stock: 3 }
// ]

Détails :

• Combinaison de deux conditions : prix >= 100 && stock > 0
• Utile pour les filtres de boutique en ligne

---

Résumé des différences map() vs filter()

Aspect	map()	filter()
Objectif	Transformer chaque élément	Sélectionner certains éléments
Retour	Tableau de même taille	Tableau plus petit ou égal
Fonction	Retourne la valeur transformée	Retourne true ou false
Exemple	[1,2,3].map(n => n*2) → [2,4,6]	[1,2,3].filter(n => n>1) → [2,3]

---

Conseils pratiques

✅ À faire :

• Utiliser map() pour transformer des données
• Utiliser filter() pour nettoyer/sélectionner des données
• Combiner les deux : array.filter(...).map(...)
• Tester avec console.log() à chaque étape

❌ À éviter :

• Modifier le tableau original (ces méthodes retournent un nouveau tableau)
• Oublier les parenthèses autour des objets retournés par map()
• Utiliser filter() pour transformer (utiliser map() à la place)

TP 2, 3 et 4 - Corrigés et Détaillés

---

TP 2 : filter() - Sélectionner les données (Complet)

La méthode filter() crée un nouveau tableau contenant seulement les éléments qui satisfont une condition.

Syntaxe : tableau.filter((element, index, array) => condition)

---

Exercice 2.1 : Filtrage numérique

Énoncé : Avec nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], filtrez selon différents critères.

Correction complète :

const nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 1. Garder seulement les nombres pairs
const pairs = nombres.filter((n) => n % 2 === 0);
console.log(pairs); // [2, 4, 6, 8, 10]

// 2. Garder seulement les nombres > 5
const superieursCinq = nombres.filter((n) => n > 5);
console.log(superieursCinq); // [6, 7, 8, 9, 10]

// 3. Garder seulement les nombres entre 3 et 7 (inclus)
const entre3et7 = nombres.filter((n) => n >= 3 && n <= 7);
console.log(entre3et7); // [3, 4, 5, 6, 7]

Détails pédagogiques :

• n % 2 === 0 : l’opérateur modulo % retourne le reste de la division. Si le reste est 0, le nombre est pair
• && : opérateur ET logique (les deux conditions doivent être vraies)
• || : opérateur OU logique (au moins une condition doit être vraie)

---

Exercice 2.2 : Filtrage d’objets (utilisateurs)

Énoncé : Filtrez un tableau d’utilisateurs selon différents critères.

Correction complète :

const utilisateurs = [
    { nom: 'Alice', age: 25, ville: 'Paris' },
    { nom: 'Bob', age: 17, ville: 'Lyon' },
    { nom: 'Charlie', age: 35, ville: 'Paris' },
];

// 1. Garder seulement les majeurs (age >= 18)
const majeurs = utilisateurs.filter((u) => u.age >= 18);
console.log(majeurs);
// [
//   { nom: 'Alice', age: 25, ville: 'Paris' },
//   { nom: 'Charlie', age: 35, ville: 'Paris' }
// ]

// 2. Garder seulement les habitants de Paris
const parisiens = utilisateurs.filter((u) => u.ville === 'Paris');
console.log(parisiens);
// [
//   { nom: 'Alice', age: 25, ville: 'Paris' },
//   { nom: 'Charlie', age: 35, ville: 'Paris' }
// ]

// 3. Garder les majeurs de Paris (condition composée)
const majeursDeParis = utilisateurs.filter((u) => u.age >= 18 && u.ville === 'Paris');
console.log(majeursDeParis);
// [
//   { nom: 'Alice', age: 25, ville: 'Paris' },
//   { nom: 'Charlie', age: 35, ville: 'Paris' }
// ]

Détails pédagogiques :

• u.ville === 'Paris' : comparaison stricte avec === (type et valeur)
• Accès aux propriétés d’objets : u.age, u.ville
• Combinaison de conditions pour des filtres complexes

---

Exercice 2.3 : Filtrage de produits

Énoncé : Filtrez un tableau de produits selon le stock et le prix.

Correction complète :

const produits = [
    { nom: 'Laptop', prix: 1200, stock: 5 },
    { nom: 'Souris', prix: 25, stock: 0 },
    { nom: 'Clavier', prix: 85, stock: 12 },
    { nom: 'Écran', prix: 350, stock: 3 },
    { nom: 'Câble USB', prix: 8, stock: 50 },
];

// 1. Produits en stock (stock > 0)
const enStock = produits.filter((p) => p.stock > 0);
console.log(enStock);
// [
//   { nom: 'Laptop', prix: 1200, stock: 5 },
//   { nom: 'Clavier', prix: 85, stock: 12 },
//   { nom: 'Écran', prix: 350, stock: 3 },
//   { nom: 'Câble USB', prix: 8, stock: 50 }
// ]

// 2. Produits moins chers que 100€
const moinsCher100 = produits.filter((p) => p.prix < 100);
console.log(moinsCher100);
// [
//   { nom: 'Souris', prix: 25, stock: 0 },
//   { nom: 'Clavier', prix: 85, stock: 12 },
//   { nom: 'Câble USB', prix: 8, stock: 50 }
// ]

// 3. Produits chers (>= 100€) ET en stock
const chersEnStock = produits.filter((p) => p.prix >= 100 && p.stock > 0);
console.log(chersEnStock);
// [
//   { nom: 'Laptop', prix: 1200, stock: 5 },
//   { nom: 'Écran', prix: 350, stock: 3 }
// ]

Détails pédagogiques :

• Combinaison de deux conditions numériques
• Cas d’usage réel : filtres de boutique en ligne
• Peut être chaîné avec d’autres méthodes : produits.filter(...).map(...)

---

---

TP 3 : reduce() - Agréger les données

La méthode reduce() combine tous les éléments d’un tableau en une seule valeur.

Syntaxe : tableau.reduce((accumulateur, element, index, array) => { ... }, valeurInitiale)

Paramètres :

• accumulateur : accumule le résultat au fil des itérations
• element : élément courant
• valeurInitiale : valeur de départ (optionnelle mais recommandée)

---

Exercice 3.1 : Opérations numériques avec reduce()

Énoncé : Avec nombres = [1, 2, 3, 4, 5], utilisez reduce() pour calculer la somme, le produit et le maximum.

Correction complète :

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

// 1. Calculer la somme de tous les nombres
const somme = nombres.reduce((acc, n) => acc + n, 0);
console.log(somme); // 15

// Détail du processus :
// Itération 1 : acc = 0, n = 1 → 0 + 1 = 1
// Itération 2 : acc = 1, n = 2 → 1 + 2 = 3
// Itération 3 : acc = 3, n = 3 → 3 + 3 = 6
// Itération 4 : acc = 6, n = 4 → 6 + 4 = 10
// Itération 5 : acc = 10, n = 5 → 10 + 5 = 15

// 2. Calculer le produit de tous les nombres
const produit = nombres.reduce((acc, n) => acc * n, 1);
console.log(produit); // 120 (1 × 2 × 3 × 4 × 5)

// 3. Trouver le nombre maximum
const maximum = nombres.reduce((acc, n) => (n > acc ? n : acc), nombres[0]);
console.log(maximum); // 5

// Alternative plus lisible :
const max = nombres.reduce((acc, n) => Math.max(acc, n), -Infinity);
console.log(max); // 5

Détails pédagogiques :

• Somme : valeur initiale = 0 (élément neutre pour l’addition)
• Produit : valeur initiale = 1 (élément neutre pour la multiplication)
• Maximum : comparaison avec l’accumulateur à chaque itération
• Math.max() : fonction intégrée pour trouver le maximum entre deux nombres

---

Exercice 3.2 : Compter les occurrences avec reduce()

Énoncé : Avec fruits = ['pomme', 'banane', 'pomme', 'orange', 'banane', 'pomme'], comptez les occurrences.

Correction complète :

const fruits = ['pomme', 'banane', 'pomme', 'orange', 'banane', 'pomme'];

// Créer un objet avec le compte de chaque fruit
const comptage = fruits.reduce((acc, fruit) => {
    // Si le fruit existe déjà, incrémenter le compte
    // Sinon, initialiser à 1
    acc[fruit] = (acc[fruit] || 0) + 1;
    return acc;
}, {});

console.log(comptage);
// { pomme: 3, banane: 2, orange: 1 }

// Explication du processus :
// Itération 1 : acc = {}, fruit = 'pomme' → acc['pomme'] = 1
// Itération 2 : acc = {pomme: 1}, fruit = 'banane' → acc['banane'] = 1
// Itération 3 : acc = {pomme: 1, banane: 1}, fruit = 'pomme' → acc['pomme'] = 2
// Itération 4 : acc = {pomme: 2, banane: 1}, fruit = 'orange' → acc['orange'] = 1
// Itération 5 : acc = {pomme: 2, banane: 1, orange: 1}, fruit = 'banane' → acc['banane'] = 2
// Itération 6 : acc = {pomme: 2, banane: 2, orange: 1}, fruit = 'pomme' → acc['pomme'] = 3

Détails pédagogiques :

• acc[fruit] || 0 : si la clé n’existe pas, utiliser 0 (opérateur OR logique)
• Valeur initiale = {} (objet vide)
• Cas d’usage : analyse de données, statistiques

---

Exercice 3.3 : Grouper par ville avec reduce()

Énoncé : Avec un tableau d’utilisateurs, groupez-les par ville.

Correction complète :

const utilisateurs = [
    { nom: 'Alice', ville: 'Paris' },
    { nom: 'Bob', ville: 'Lyon' },
    { nom: 'Charlie', ville: 'Paris' },
    { nom: 'Diana', ville: 'Lyon' },
    { nom: 'Eve', ville: 'Marseille' },
];

// Grouper les utilisateurs par ville
const parVille = utilisateurs.reduce((acc, user) => {
    const ville = user.ville;

    // Si la ville n'existe pas dans l'accumulateur, créer un tableau vide
    if (!acc[ville]) {
        acc[ville] = [];
    }

    // Ajouter l'utilisateur au tableau de sa ville
    acc[ville].push(user);
    return acc;
}, {});

console.log(parVille);
// {
//   Paris: [
//     { nom: 'Alice', ville: 'Paris' },
//     { nom: 'Charlie', ville: 'Paris' }
//   ],
//   Lyon: [
//     { nom: 'Bob', ville: 'Lyon' },
//     { nom: 'Diana', ville: 'Lyon' }
//   ],
//   Marseille: [
//     { nom: 'Eve', ville: 'Marseille' }
//   ]
// }

// Version compacte avec l'opérateur OR :
const parVilleCompact = utilisateurs.reduce((acc, user) => {
    acc[user.ville] = acc[user.ville] || [];
    acc[user.ville].push(user);
    return acc;
}, {});

Détails pédagogiques :

• Vérification d’existence : if (!acc[ville])
• Création de tableaux imbriqués
• Cas d’usage : organisation de données par catégorie

---

Exercice 3.4 : Calculer le total d’une commande

Énoncé : Avec un tableau d’articles de commande, calculez le total : (prix × quantité) pour chaque article.

Correction complète :

const articles = [
    { nom: 'Laptop', prix: 1200, quantite: 1 },
    { nom: 'Souris', prix: 25, quantite: 3 },
    { nom: 'Clavier', prix: 85, quantite: 2 },
];

// Calculer le total de la commande
const totalCommande = articles.reduce((acc, article) => {
    const sousTotal = article.prix * article.quantite;
    return acc + sousTotal;
}, 0);

console.log(totalCommande); // 1200 + 75 + 170 = 1445

// Version détaillée avec affichage des calculs :
const totalAvecDetails = articles.reduce((acc, article) => {
    const sousTotal = article.prix * article.quantite;
    console.log(`${article.nom}: ${article.prix}€ × ${article.quantite} = ${sousTotal}€`);
    return acc + sousTotal;
}, 0);

console.log(`Total: ${totalAvecDetails}€`);

// Créer un objet avec les détails de chaque article :
const commandeDetaillée = articles.reduce(
    (acc, article) => {
        return {
            ...acc,
            articles: [
                ...acc.articles,
                {
                    nom: article.nom,
                    sousTotal: article.prix * article.quantite,
                },
            ],
            total: acc.total + article.prix * article.quantite,
        };
    },
    { articles: [], total: 0 },
);

console.log(commandeDetaillée);
// {
//   articles: [
//     { nom: 'Laptop', sousTotal: 1200 },
//     { nom: 'Souris', sousTotal: 75 },
//     { nom: 'Clavier', sousTotal: 170 }
//   ],
//   total: 1445
// }

Détails pédagogiques :

• Multiplication de deux propriétés : prix × quantite
• Accumulation progressive du total
• Spread operator pour créer des objets complexes

---

---

TP 4 : find/some/every - Rechercher et vérifier les données

Ces méthodes permettent de chercher et vérifier les éléments d’un tableau.

Méthode	Retour	Utilité
find()	Premier élément trouvé	Chercher UN élément
findIndex()	Index du premier élément trouvé	Chercher la POSITION d’un élément
some()	true ou false	Vérifier si AU MOINS UN élément satisfait la condition
every()	true ou false	Vérifier si TOUS les éléments satisfont la condition

---

Exercice 4.1 : Chercher avec find() et findIndex()

Énoncé : Avec un tableau d’utilisateurs, utilisez find() et findIndex().

Correction complète :

const utilisateurs = [
    { id: 1, nom: 'Alice' },
    { id: 2, nom: 'Bob' },
    { id: 3, nom: 'Charlie' },
];

// 1. Trouver l'utilisateur avec le nom 'Bob'
const bob = utilisateurs.find((u) => u.nom === 'Bob');
console.log(bob); // { id: 2, nom: 'Bob' }

// 2. Trouver l'index de 'Bob'
const indexBob = utilisateurs.findIndex((u) => u.nom === 'Bob');
console.log(indexBob); // 1 (deuxième élément, index commence à 0)

// 3. Trouver le premier utilisateur avec id > 1
const premierIdSup1 = utilisateurs.find((u) => u.id > 1);
console.log(premierIdSup1); // { id: 2, nom: 'Bob' }

// Cas où rien n'est trouvé :
const inexistant = utilisateurs.find((u) => u.nom === 'Zorro');
console.log(inexistant); // undefined

// Vérifier si l'élément existe :
if (bob) {
    console.log(`Utilisateur trouvé: ${bob.nom}`);
} else {
    console.log('Utilisateur non trouvé');
}

Détails pédagogiques :

• find() retourne le premier élément qui satisfait la condition
• find() retourne undefined si rien n’est trouvé
• findIndex() retourne l’index (position) du premier élément trouvé
• findIndex() retourne -1 si rien n’est trouvé

---

Exercice 4.2 : Vérifier avec some() et every()

Énoncé : Avec notes = [12, 15, 18, 14, 16], vérifiez différentes conditions.

Correction complète :

const notes = [12, 15, 18, 14, 16];

// 1. Vérifier si au moins une note est >= 18
const auMoinsUne18 = notes.some((n) => n >= 18);
console.log(auMoinsUne18); // true (18 existe)

// 2. Vérifier si toutes les notes sont >= 10
const toutesSupOuEgal10 = notes.every((n) => n >= 10);
console.log(toutesSupOuEgal10); // true (toutes >= 10)

// 3. Vérifier si toutes les notes sont >= 15
const toutesSupOuEgal15 = notes.every((n) => n >= 15);
console.log(toutesSupOuEgal15); // false (12 et 14 < 15)

// Exemples supplémentaires :

// Vérifier s'il existe au moins une note < 13
const auMoinsUneMauvaise = notes.some((n) => n < 13);
console.log(auMoinsUneMauvaise); // true (12 existe)

// Vérifier si toutes les notes sont < 20
const toutesInferieur20 = notes.every((n) => n < 20);
console.log(toutesInferieur20); // true

// Cas pratique : vérifier si un étudiant a réussi
const noteMinimale = 10;
const aReussi = notes.every((n) => n >= noteMinimale);
console.log(`L'étudiant a réussi: ${aReussi}`);

Détails pédagogiques :

• some() : retourne true dès qu’une condition est satisfaite (court-circuit)
• every() : retourne false dès qu’une condition n’est pas satisfaite (court-circuit)
• Optimisation : les boucles s’arrêtent dès que le résultat est déterminé

---

Exercice 4.3 : Vérifier l’état des produits

Énoncé : Avec un tableau de produits, vérifiez l’existence et les conditions.

Correction complète :

const produits = [
    { nom: 'Laptop', prix: 1200, stock: 5 },
    { nom: 'Souris', prix: 25, stock: 0 },
    { nom: 'Clavier', prix: 85, stock: 12 },
    { nom: 'Écran', prix: 350, stock: 0 },
    { nom: 'Câble USB', prix: 8, stock: 50 },
];

// 1. S'il existe au moins un produit en stock
const existeEnStock = produits.some((p) => p.stock > 0);
console.log(`Au moins un produit en stock: ${existeEnStock}`); // true

// 2. Si tous les produits coûtent moins de 1000€
const tousUnderPrice = produits.every((p) => p.prix < 1000);
console.log(`Tous les produits < 1000€: ${tousUnderPrice}`); // false (Laptop = 1200€)

// Cas pratiques supplémentaires :

// Vérifier si tous les produits sont en stock
const tousEnStock = produits.every((p) => p.stock > 0);
console.log(`Tous les produits en stock: ${tousEnStock}`); // false

// Vérifier s'il existe au moins un produit cher (>= 300€)
const existeProduitCher = produits.some((p) => p.prix >= 300);
console.log(`Existe un produit >= 300€: ${existeProduitCher}`); // true

// Vérifier s'il existe au moins un produit sans stock
const existeSansStock = produits.some((p) => p.stock === 0);
console.log(`Existe un produit sans stock: ${existeSansStock}`); // true

// Afficher un message selon la disponibilité
if (produits.some((p) => p.stock > 0)) {
    console.log('✅ La boutique a des articles en stock');
} else {
    console.log('❌ Tous les articles sont en rupture de stock');
}

Détails pédagogiques :

• some() : idéal pour vérifier l’existence d’au moins un élément
• every() : idéal pour vérifier que TOUS les éléments satisfont une condition
• Cas d’usage réel : gestion de stock, validation de formulaires

---

---

Résumé comparatif : Toutes les méthodes

Méthode	Retour	Modifie le tableau	Cas d’usage
map()	Nouveau tableau transformé	Non	Transformer chaque élément
filter()	Nouveau tableau filtré	Non	Sélectionner certains éléments
reduce()	Une seule valeur	Non	Agréger/combiner tous les éléments
find()	Premier élément trouvé	Non	Chercher UN élément
findIndex()	Index du premier élément	Non	Chercher la POSITION d’un élément
some()	true ou false	Non	Vérifier si AU MOINS UN élément satisfait
every()	true ou false	Non	Vérifier si TOUS les éléments satisfont

---

Conseils pratiques

✅ À faire :

• Utiliser map() pour transformer
• Utiliser filter() pour sélectionner
• Utiliser reduce() pour agréger
• Utiliser find() pour chercher un élément
• Utiliser some()/every() pour vérifier des conditions
• Chaîner les méthodes : array.filter(...).map(...).reduce(...)
• Tester avec console.log() à chaque étape

❌ À éviter :

• Modifier le tableau original (ces méthodes retournent de nouvelles valeurs)
• Utiliser filter() pour chercher (utiliser find() à la place)
• Oublier la valeur initiale dans reduce()
• Confondre some() et every()

---

Chaînage de méthodes (Bonus)

const utilisateurs = [
    { nom: 'Alice', age: 25, ville: 'Paris' },
    { nom: 'Bob', age: 17, ville: 'Lyon' },
    { nom: 'Charlie', age: 35, ville: 'Paris' },
];

// Chaîner filter → map → reduce
const resultat = utilisateurs
    .filter((u) => u.age >= 18) // Garder les majeurs
    .map((u) => u.nom) // Extraire les noms
    .reduce((acc, nom) => acc + nom + ', ', ''); // Combiner en chaîne

console.log(resultat); // "Alice, Charlie, "