const utilisateur = {
    nom: "Alice",
    age: 30,
    adresse: { ville: "Paris", codePostal: "75001" },
};

// Destructuring de base, avec renommage et valeurs par defaut
const { nom, age: ageUtilisateur, pays = "France" } = utilisateur;

// Destructuring imbrique
const { adresse: { ville, codePostal } } = utilisateur;

// Destructuring dans les parametres de fonction (tres courant en React/Node)
function afficherProfil({ nom, age, adresse: { ville } = {} }) {
    console.log(`${nom}, ${age} ans, ${ville}`);
}
afficherProfil(utilisateur);

// Spread : copier/fusionner des objets sans mutation
const utilisateurMisAJour = { ...utilisateur, age: 31 };           // shallow copy + override
const fusion = { ...utilisateur, ...{ theme: "sombre" } };
console.log(utilisateur.age);       // 30 -- l'original n'est PAS modifie

// ATTENTION : le spread est une copie SUPERFICIELLE (shallow)
const copieSuperficielle = { ...utilisateur };
copieSuperficielle.adresse.ville = "Lyon";
console.log(utilisateur.adresse.ville);   // "Lyon" -- impacte, car adresse est partagee !

// Copie profonde : structuredClone (natif, moderne) ou JSON (avec limites)
const copieProfonde = structuredClone(utilisateur);
copieProfonde.adresse.ville = "Marseille";
console.log(utilisateur.adresse.ville);    // toujours "Lyon", non impacte

// Rest operator sur un objet : extraire certaines cles, garder le reste
const { nom: nomExtrait, ...proprietesRestantes } = utilisateur;
console.log(proprietesRestantes);    // { age: 30, adresse: {...} }

// Object.entries / keys / values : passer d'un objet a des structures iterables
console.log(Object.keys(utilisateur));
console.log(Object.values(utilisateur));
console.log(Object.entries(utilisateur));

for (const [cle, valeur] of Object.entries(utilisateur)) {
    console.log(`${cle}: ${JSON.stringify(valeur)}`);
}

// Object.fromEntries : reconstruire un objet depuis des paires
const doubleValeurs = Object.fromEntries(
    Object.entries({ a: 1, b: 2 }).map(([cle, val]) => [cle, val * 2])
);

// Computed property names : cles dynamiques
const cleDynamique = "statut";
const objet = { [cleDynamique]: "actif", [`${cleDynamique}_depuis`]: "2024" };

// Object.freeze / Object.seal : immuabilite (superficielle uniquement)
const constante = Object.freeze({ pi: 3.14159 });
constante.pi = 4;                 // ignore silencieusement (ou erreur en mode strict)
console.log(constante.pi);          // 3.14159 toujours

// Property shorthand
function creerPoint(x, y) {
    return { x, y };               // equivalent a { x: x, y: y }
}

// Getters/setters dans un objet litteral
const compte = {
    _solde: 100,
    get solde() {
        return `${this._solde} EUR`;
    },
    set solde(valeur) {
        if (valeur < 0) throw new Error("Solde negatif interdit");
        this._solde = valeur;
    },
};
console.log(compte.solde);
compte.solde = 200;

// Object.assign : alternative pre-spread, mute le premier argument
const cible = { a: 1 };
Object.assign(cible, { b: 2 }, { c: 3 });
console.log(cible);    // { a: 1, b: 2, c: 3 }

// Comparaison d'objets : reference, pas structure
console.log({ a: 1 } === { a: 1 });      // false : deux objets differents en memoire
console.log(JSON.stringify({ a: 1 }) === JSON.stringify({ a: 1 }));   // true (comparaison textuelle)