// Les 3 façons de déclarer une variable
const nom   = "Alice";   // ← par défaut : const
let   score = 0;        // ← si la valeur va changer
var   age   = 30;       // ← à éviter

// const sans valeur → erreur immédiate
const x; // SyntaxError: Missing initializer

// let sans valeur → undefined
let y;   // y === undefined

// ① Portée fonction (pas bloc)
if (true) {
  var x = 10; // var ignore le bloc {}
}
console.log(x); // 10 ← visible ici !

// ② Re-déclaration silencieuse
var utilisateur = "Alice";
// ... 200 lignes plus tard ...
var utilisateur = "Bob"; // aucune erreur ! Alice écrasée silencieusement

// ③ Bug classique des boucles
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);
}
// Affiche : 3, 3, 3  (pas 0, 1, 2 !)
// var i est partagée entre toutes les itérations

const PI = 3.14;
PI = 3; // TypeError: Assignment to constant variable ✓

// ⚠️ const n'empêche PAS la mutation
const user = { nom: "Alice" };
user.nom = "Bob"; // ✓ OK — on mute l'objet, pas la liaison
user = {};        // TypeError — réassignation interdite

// Pour vraiment geler un objet :
const config = Object.freeze({ api: "https://..." });
config.api = "autre"; // silencieusement ignoré

const txt  = "Bonjour";        // string
const n    = 42;               // number  (entiers ET flottants)
const big  = 9007199254740993n; // bigint
const ok   = true;             // boolean
const vide = null;             // null    (absence intentionnelle)
let   u;                       // undefined (non initialisé)
const id   = Symbol("id");     // symbol  (unique)

// Type object (tout le reste)
const obj  = { a: 1 };         // object
const arr  = [1, 2];           // object (tableau)
const fn   = () => {};          // function

typeof "hello"      // "string"
typeof 42           // "number"
typeof true         // "boolean"
typeof undefined    // "undefined"
typeof {}           // "object"
typeof []           // "object"  ← tableau = objet
typeof null         // "object"  ← bug historique de JS !
typeof function(){}  // "function"

// Vérification fiable de null :
value === null

// Vérification fiable de tableau :
Array.isArray([]); // true ✓

// 1. Portée globale
const GLOBAL = "visible partout";

function externe() {
  // 2. Portée fonction
  const locale = "dans externe()";

  function interne() {
    // 3. Portée imbriquée — closure
    console.log(GLOBAL);  // ✓ accessible
    console.log(locale);  // ✓ accessible (closure)

    // 4. Portée bloc
    if (true) {
      let bloc = "seulement ici";
    }
    // console.log(bloc); // ReferenceError
  }
}

// console.log(locale); // ReferenceError — invisible dehors

// var : hissée ET initialisée à undefined
console.log(x); // undefined (pas d'erreur !)
var x = 5;

// Fonctions : entièrement hissées
direBonjour(); // ✓ fonctionne avant la déclaration
function direBonjour() { console.log("Bonjour !"); }

// let / const : hissées mais PAS initialisées → TDZ
console.log(nom); // ReferenceError: Cannot access before initialization
let nom = "Alice"; // ← fin de la TDZ

// + avec string = concaténation
"3" + 4       // "34"
1 + 2 + "3"  // "33" (1+2=3, puis 3+"3")

// Autres opérateurs = coercition numérique
"5" - 2       // 3
true + 1     // 2  (true → 1)
null + 1     // 1  (null → 0)

// == coerce, === ne coerce pas
"1" == 1     // true  ← dangereux
"1" === 1    // false ← correct
[] == false  // true  😱
[] == ![]    // true  😱😱

// → Number
Number("42")       // 42
Number("abc")      // NaN
+"42"              // 42 (unary plus)
parseInt("42px")  // 42

// → String
String(42)          // "42"
(42).toString(2)  // "101010" (binaire)

// → Boolean
Boolean(0)          // false
Boolean("0")        // true ! (string non vide)
Boolean([])         // true ! (objet)
!!value             // double négation — idiomatique

// || valeur par défaut — attention aux falsy !
const nom  = "" || "Anonyme";  // "Anonyme" (car "" est falsy)
const port = 0 || 3000;       // 3000 — bug ! 0 est falsy

// ?? nullish coalescing — uniquement null/undefined
const nom2  = "" ?? "Anonyme"; // "" ← correct !
const port2 = 0 ?? 3000;      // 0  ← correct !

// ??= assigne seulement si null/undefined
let config = {};
config.debug ??= false;  // assigne seulement si absent
config.nom   ||= "défaut"; // assigne si falsy