JavaScript - Objets, Contrôle et Nouveautés (Version Simplifiée)

3.1 Les Objets en JavaScript

Créer et utiliser un objet

Un objet est une collection de données organisées en clé: valeur.

Exemple simple :

const utilisateur = {
    nom: 'Eva',
    age: 25,
    ville: 'Lyon',

    // Une méthode (fonction dans l'objet)
    sePresenter() {
        return `Je suis ${this.nom} et j'ai ${this.age} ans`;
    },
};

console.log(utilisateur.nom); // "Eva"
console.log(utilisateur.sePresenter()); // "Je suis Eva et j'ai 25 ans"

Propriétés avec espaces et accès dynamique

const profil = {
    'date de naissance': '1999-05-15',
    email: 'eva@example.com',
};

// Accès avec crochets pour les espaces
console.log(profil['date de naissance']); // "1999-05-15"

// Propriétés calculées
const cle = 'email';
console.log(profil[cle]); // "eva@example.com"

Getters et Setters (propriétés calculées)

const personne = {
    nom: 'Eva',
    _age: 25, // Convention : _ = propriété privée

    // Getter : lire une propriété calculée
    get ageEnDecennie() {
        return Math.floor(this._age / 10) * 10;
    },

    // Setter : modifier avec validation
    set email(nouvelEmail) {
        if (!nouvelEmail.includes('@')) {
            throw new Error('Email invalide');
        }
        this._email = nouvelEmail;
    },

    get email() {
        return this._email || 'Non défini';
    },
};

console.log(personne.ageEnDecennie); // 20
personne.email = 'eva@example.com';
console.log(personne.email); // "eva@example.com"

Méthodes utiles sur les objets

Méthode	Utilité
`Object.keys(obj)`	Récupère toutes les clés
`Object.values(obj)`	Récupère toutes les valeurs
`Object.entries(obj)`	Récupère les paires clé-valeur
`Object.assign(dest, src)`	Fusionne des objets
`Object.hasOwn(obj, clé)`	Vérifie si une clé existe

Exemple :

const utilisateur = { nom: 'Eva', age: 25, ville: 'Lyon' };

Object.keys(utilisateur); // ["nom", "age", "ville"]
Object.values(utilisateur); // ["Eva", 25, "Lyon"]
Object.entries(utilisateur); // [["nom", "Eva"], ["age", 25], ["ville", "Lyon"]]

// Fusionner deux objets
const complet = Object.assign({}, utilisateur, { pays: 'France' });
// { nom: "Eva", age: 25, ville: "Lyon", pays: "France" }

3.2 Les Structures de Contrôle

3.2.1 Conditions : if/else et ternaire

const age = 22;

// if/else classique
if (age < 18) {
    console.log('Mineur');
} else if (age < 25) {
    console.log('Jeune adulte');
} else {
    console.log('Adulte');
}

// Ternaire (condition simple)
const statut = age >= 18 ? 'Majeur' : 'Mineur';
console.log(statut); // "Majeur"

3.2.2 Switch avec pattern matching

const role = 'admin';

switch (role) {
    case 'admin':
        console.log('Accès complet');
        break;
    case 'moderator':
        console.log('Modération');
        break;
    default:
        console.log('Lecture seule');
}

// Switch avancé (switch(true))
const donnee = [1, 2, 3];

switch (true) {
    case typeof donnee === 'string':
        console.log('Texte');
        break;
    case Array.isArray(donnee):
        console.log(`Tableau de ${donnee.length} éléments`);
        break;
    case typeof donnee === 'object':
        console.log('Objet');
        break;
}

3.2.3 Boucles modernes

for…of (pour les valeurs)

const notes = [12, 15, 18];

for (const note of notes) {
    console.log(note); // 12, 15, 18
}

for…in (pour les clés d’objets)

const utilisateur = { nom: 'Eva', age: 25 };

for (const cle in utilisateur) {
    console.log(`${cle}: ${utilisateur[cle]}`);
}

while et do…while

let i = 0;
while (i < 3) {
    console.log(i);
    i++;
}

// do...while : exécute au moins une fois
do {
    console.log('Au moins une fois');
} while (false);

3.2.4 Gestion des erreurs : try/catch/finally

Syntaxe Générale

try {
    // Code à exécuter
    // Peut générer une erreur
} catch (erreur) {
    // Code exécuté si une erreur se produit
} finally {
    // Code TOUJOURS exécuté (optionnel)
}

function diviser(a, b) {
    try {
        if (b === 0) {
            throw new Error('Division par zéro impossible');
        }
        return a / b;
    } catch (erreur) {
        console.error('Erreur:', erreur.message);
        return null;
    } finally {
        console.log('Opération terminée');
    }
}

diviser(10, 2); // 5
diviser(10, 0); // null + message d'erreur

Diagramme de Flux

┌─────────────────────────────────────────┐
│         Appel de diviser(10, 2)         │
└────────────────┬────────────────────────┘
                 ↓
         ┌───────────────────┐
         │   BLOC TRY        │
         ├───────────────────┤
         │ Vérifier b === 0? │
         │ NON → Pas d'erreur│
         │ Calculer a / b    │
         │ return 5          │
         └────────┬──────────┘
                  ↓
         ┌───────────────────┐
         │  BLOC CATCH       │
         │  (IGNORÉ)         │
         │  Pas d'erreur     │
         └────────┬──────────┘
                  ↓
         ┌───────────────────┐
         │  BLOC FINALLY     │
         │  Affiche message  │
         └────────┬──────────┘
                  ↓
         ┌───────────────────┐
         │   Retour : 5      │
         └───────────────────┘

. Analyse Détaillée de Chaque Bloc**

A. Le Bloc TRY

try {
    if (b === 0) {
        throw new Error('Division par zéro impossible');
    }
    return a / b;
}

Rôle : Contient le code qui peut générer une erreur.

Étape 1 : Vérification de la Condition

if (b === 0) {
    throw new Error('Division par zéro impossible');
}

Condition	Action
`b === 0`	Lance une erreur
`b !== 0`	Continue l’exécution

Étape 2 : Lancer une Erreur avec `throw`

throw new Error('Division par zéro impossible');

Signification :

throw : Lance (lance) une exception
new Error(...) : Crée un objet erreur
Le message : 'Division par zéro impossible'

Analogie :

Sans throw :
┌─────────────────┐
│ Code continue   │
└─────────────────┘

Avec throw :
┌─────────────────┐
│ ARRÊT !         │
│ Erreur lancée   │
│ Saute au catch  │
└─────────────────┘

Étape 3 : Calcul Normal

return a / b;

Si b !== 0, le calcul se fait normalement et retourne le résultat.

B. Le Bloc CATCH

catch (erreur) {
    console.error('Erreur:', erreur.message);
    return null;
}

Rôle : S’exécute UNIQUEMENT si une erreur est lancée dans le bloc try.

Paramètre `erreur`

catch (erreur) {
    // erreur est un objet Error
}

Propriétés de l’objet erreur :

Propriété	Contenu	Exemple
`erreur.message`	Le message d’erreur	`'Division par zéro impossible'`
`erreur.name`	Type d’erreur	`'Error'`
`erreur.stack`	Pile d’appels	Trace complète

Affichage de l’Erreur

console.error('Erreur:', erreur.message);

Résultat :

Erreur: Division par zéro impossible

Retour de `null`

return null;

En cas d’erreur, la fonction retourne null au lieu d’une valeur numérique.

C. Le Bloc FINALLY

finally {
    console.log('Opération terminée');
}

Rôle : S’exécute TOUJOURS, qu’il y ait erreur ou non.

Cas 1 : Pas d’erreur

try → Succès → finally → Retour

Cas 2 : Avec erreur

try → Erreur → catch → finally → Retour

Important : Le finally s’exécute AVANT le return.

4. Exécution Pas à Pas

Exemple 1 : `diviser(10, 2)`

diviser(10, 2);

Flux d’exécution :

1. Appel : diviser(10, 2)
   a = 10, b = 2

2. Bloc TRY
   ├─ Vérifier : b === 0 ?
   │  └─ 2 === 0 ? NON
   ├─ Pas d'erreur lancée
   ├─ Calculer : 10 / 2 = 5
   └─ return 5

3. Bloc CATCH
   └─ IGNORÉ (pas d'erreur)

4. Bloc FINALLY
   └─ console.log('Opération terminée')
      Affiche : "Opération terminée"

5. Retour : 5

Sortie Console :

Opération terminée
5

Exemple 2 : `diviser(10, 0)`

diviser(10, 0);