Module 3 -- Structures de Contrôle et Collections : Les Décisions Qui Enchaînent

let heure = 14;

if (heure < 12) {
  console.log("Le matin est encore frais.");
} else if (heure < 18) {
  console.log("L'après-midi traîne, lourde."); // ← Ça passe ici
} else {
  console.log("La nuit tombe. Le bon moment.");
}

// Conditions complexes : croiser les pistes
let âge = 20;
let aLesClés = true;

if (âge >= 18 && aLesClés) {
  console.log("La voiture est à toi.");
} else if (âge >= 18 && !aLesClés) {
  console.log("Il te faut les clés d'abord.");
} else {
  console.log("Reviens plus grand.");
}

let jour = "Mardi";

switch (jour) {
  case "Lundi":
    console.log("La semaine saigne encore.");
    break; // IMPORTANT : casse la chaîne ici
  case "Mardi":
  case "Mercredi":
  case "Jeudi":
    console.log("Les jours se ressemblent."); // Pour ces trois-là
    break;
  case "Vendredi":
    console.log("L'air sent la fuite.");
    break;
  case "Samedi":
  case "Dimanche":
    console.log("Le temps s'arrête. Un peu.");
    break;
  default: // Si rien ne correspond
    console.log("Ce jour n'existe pas dans mes registres.");
}

// Oublie le `break`, et le code coule dans le cas suivant. Une erreur classique.

let âge = 20;

// Syntaxe : condition ? si_vrai : si_faux
let statut = âge >= 18 ? "Dans le jeu" : "Trop vert";
console.log(statut); // "Dans le jeu"

// On peut enchaîner, mais ça devient sombre
let score = 85;
let grade = score >= 90 ? "Maître" :
            score >= 75 ? "Confirmé" :
            score >= 50 ? "Novice" : "Amateur";

let contact = null; // La source a tari

// L'ancienne méthode, lourde
let ville = contact && contact.adresse && contact.adresse.ville;

// La nouvelle, avec `?.` (l'opérateur elvis)
let ville = contact?.adresse?.ville;
// Si contact est null/undefined → retourne undefined
// Si adresse est null/undefined → retourne undefined
// Sinon, donne la ville

console.log(ville); // undefined (sans faire exploser la console)

// Marche aussi pour appeler des fonctions fantômes
contact?.donnerAlerte?.(); // Appelle seulement si la fonction existe

// De 1 à 5, comme des coups frappés à la porte
for (let i = 1; i <= 5; i++) {
  console.log("Coup numéro", i);
}
// i=1 → 1≤5 vrai → frappe → i++ → i=2 → etc.

// Parcourir une liste (la façon ancienne)
let noms = ["Marlowe", "Spade", "Hammer"];
for (let i = 0; i < noms.length; i++) {
  console.log(`Suspect ${i}: ${noms[i]}`);
}

// while : vérifie avant d'agir
let tentative = 0;
while (tentative < 3) {
  console.log("Tentative", tentative);
  tentative++;
}

// do...while : agit une fois, puis vérifie
let réponse;
do {
  réponse = prompt("Dis 'oui' ou 'non'. Rien d'autre."); // prompt, une fenêtre pop-up intrusive
} while (réponse !== "oui" && réponse !== "non");
// Une fois minimum, puis recommence si la réponse pue.

let individu = {
  nom: "Johnson",
  âge: 42,
  métier: "détective"
};

for (let clé in individu) {
  console.log(`${clé}: ${individu[clé]}`);
}
// Affiche:
// nom: Johnson
// âge: 42
// métier: détective

// Pour les tableaux, évite for...in. Utilise for...of.

let preuves = ["empreinte", "fibre", "témoignage"];

// Plus propre, plus direct.
for (let preuve of preuves) {
  console.log(preuve);
}
// empreinte
// fibre
// témoignage

// Ça marche aussi avec les chaînes
for (let caractère of "ADN") {
  console.log(caractère); // "A", puis "D", puis "N"
}

// break : casse la boucle net
for (let i = 1; i <= 10; i++) {
  if (i === 5) {
    console.log("Stop net à 5.");
    break; // Sort de la boucle. Immédiat.
  }
  console.log(i); // Affiche 1, 2, 3, 4
}

// continue : saute un tour
for (let i = 1; i <= 5; i++) {
  if (i === 3) {
    continue; // Ignore le reste du tour pour i=3
  }
  console.log(i); // Affiche 1, 2, 4, 5
}

// 3 façons, une seule compte
let indices = ["cigarette", "argent", "menace"]; // La bonne
let nombres = new Array(10, 20, 30); // L'archaïque
let vide = []; // Le vide prometteur

// Tout est permis dans un tableau
let fouillis = [42, "aveu", false, null, {arme: "poignard"}];

let suspects = ["Marlow", "Jones", "Smith"];

// Lire par index (ça commence à 0)
console.log(suspects[0]); // "Marlow"
console.log(suspects[2]); // "Smith"
console.log(suspects[5]); // undefined (case vide)

// Modifier
suspects[1] = "Miller";
console.log(suspects); // ["Marlow", "Miller", "Smith"]

// Ajouter à la fin
suspects.push("Taylor");
console.log(suspects); // ["Marlow", "Miller", "Smith", "Taylor"]

// Retirer le dernier
let dernier = suspects.pop();
console.log(dernier); // "Taylor"
console.log(suspects); // ["Marlow", "Miller", "Smith"]

let list = ["a", "b", "c"];
console.log(list.length); // 3

// length n'est pas une constante. On peut la tordre.
list.length = 2; // Tronque
console.log(list); // ["a", "b"]

list.length = 5; // Agrandit avec du vide
console.log(list); // ["a", "b", empty × 3]
console.log(list[4]); // undefined

// Pour vider d'un coup :
list.length = 0;
console.log(list); // []

// Récupérer le dernier (astuce de vieux renard)
let dossier = [10, 20, 30];
console.log(dossier[dossier.length - 1]); // 30

let items = ["cigare", "corde"];

// Ajouter/retirer au début
items.unshift("chapeau"); // ["chapeau", "cigare", "corde"]
let premier = items.shift(); // "chapeau", reste ["cigare", "corde"]

// Trouver l'index d'un élément
let position = items.indexOf("corde"); // 1
let pasTrouvé = items.indexOf("armes"); // -1

// Vérifier la présence
console.log(items.includes("cigare")); // true

// Fusionner des listes
let armes = ["revolver", "couteau"];
let inventaire = items.concat(armes);
console.log(inventaire); // ["cigare", "corde", "revolver", "couteau"]