Cours JavaScript

Explique comment JavaScript s'exécute à la fois dans le navigateur et Node.js, l'ordre d'apprentissage des 4 catégories du cours, et comment lire un message d'erreur.

Couvre le choix entre const et let, le TypeError d'une réaffectation de const et le SyntaxError d'une redéclaration, et les règles de nommage en camelCase.

Couvre comment entiers et décimaux partagent le même type Number, les opérateurs de modulo et d'exposant, l'arrondi avec Math, l'alignement des décimales avec toFixed, et éviter les erreurs de virgule flottante.

Couvre le choix entre 3 styles de guillemets, l'intégration de valeurs avec les littéraux de gabarit, le formatage avec trim et slice, split et join, et replaceAll et padStart.

Couvre la différence entre === (vérifie type et valeur) et == (convertit le type avant de comparer), les opérateurs de comparaison et logiques, les 6 valeurs falsy que if traite comme fausses, et définir une valeur par défaut avec ||.

Couvre vérifier le type avec typeof, la conversion explicite avec Number / String / Boolean, la conversion implicite où seul + devient concaténation de chaînes, parseInt et parseFloat, et détecter les conversions échouées avec Number.isNaN.

Couvre récupérer des éléments avec index et length, ajouter et retirer avec push / pop / shift / unshift, vérifier avec includes et indexOf, et choisir entre slice et splice.

Couvre construire un objet qui regroupe des données en paires clé-valeur, choisir entre notation pointée et notation entre crochets, delete et in, et Object.keys / values / entries.

Couvre la différence entre null et undefined pour représenter « aucune valeur », lire à travers un chemin imbriqué sans s'arrêter avec ?., et appliquer une valeur par défaut avec ?? qui laisse 0 et une chaîne vide intacts.

Couvre la déstructuration, qui extrait juste les valeurs dont tu as besoin dans des variables d'un coup en faisant correspondre les noms de clés d'un objet ou les positions d'un tableau — via valeurs par défaut, renommage, et rest.

Couvre la syntaxe spread, qui dispose le contenu d'un tableau ou objet sur place, pour copier et combiner sans changer l'original, et superposer juste les changements d'un utilisateur sur des paramètres par défaut.

Couvre dédoublonner avec Set, qui ne garde qu'1 exemplaire de chaque valeur, set / get de Map pour des paires clé-valeur gardées dans l'ordre d'enregistrement, et choisir entre Map et Object selon le type de clé et l'ordre.

Couvre comment assigner un tableau ou objet ne passe qu'une référence, comment === compare des références, la copie superficielle de la syntaxe spread contre la copie profonde de structuredClone, et Object.freeze.

Couvre JSON.stringify pour transformer un objet en chaîne et JSON.parse pour le reconvertir, indenter avec un 3e argument, le SyntaxError qu'une chaîne cassée lève, et les valeurs perdues dans l'aller-retour.

Résume le partage entre les 7 primitives et Object, ce que renvoie typeof, pourquoi null et les tableaux reviennent tous les deux comme object plus Array.isArray, et comment vérifier si quelque chose peut être traité comme un nombre.

else if qui teste de haut en bas et l'ordre dans lequel placer les conditions, l'opérateur ternaire qui renvoie directement une valeur, et le rôle de switch et break pour comparer une valeur à plusieurs candidats.

for qui compte avec trois expressions (initialisation, condition, mise à jour), for...of et entries pour récupérer directement les éléments, for...in pour parcourir les clés, et comment construire des boucles imbriquées.

while pour répéter tant qu'une condition est vraie, do...while pour exécuter d'abord le corps, comment éviter les boucles infinies, et continue pour sauter un tour ou break pour sortir de la boucle.

Les déclarations function qui donnent un nom à un traitement, la correspondance des arguments par position, ce que renvoie return, les expressions de fonction qui rangent une fonction dans une variable, et le undefined d'un return oublié.

La forme de base des fonctions fléchées avec =>, les formes courtes sans parenthèses autour du paramètre ni accolades autour du corps, les parenthèses nécessaires pour renvoyer un objet, et les corps en bloc sur plusieurs lignes avec return.

Les paramètres par défaut utilisés quand un argument est omis, pourquoi undefined et null ne donnent pas le même résultat, les paramètres du reste qui regroupent les arguments restants dans un tableau, et le motif options qui transmet des réglages dans un objet.

La portée de bloc et la portée de fonction délimitées par les accolades, le masquage d'une variable extérieure par une déclaration intérieure, le hoisting des déclarations function, la TDZ de let, et pourquoi ne pas utiliser var.

Les closures, des fonctions qui gardent en mémoire les variables d'une portée extérieure : des compteurs qui conservent leur valeur d'un appel à l'autre, des fabriques qui renvoient des fonctions avec un réglage intégré, et des fonctions créées dans une boucle.

Les fonctions d'ordre supérieur, qui reçoivent des fonctions en argument, et les callbacks qu'on leur passe : traiter les éléments un par un avec forEach, un filter fait maison qui reçoit un test, et des appels en deux temps à des fonctions qui renvoient des fonctions.

map transforme chaque élément, filter ne garde que ceux qui remplissent une condition. Tu verras pourquoi le tableau d'origine ne bouge pas, comment chaîner filter puis map, et à quoi sert l'argument index.

reduce combine un tableau en une seule valeur. Tu verras comment l'accumulateur et la valeur initiale se transmettent, comment calculer un total, un maximum ou un décompte par catégorie, et la TypeError d'un tableau vide.

sort, dont l'ordre dépend de ce que renvoie la fonction de comparaison, toSorted, qui garde le tableau d'origine, find et findIndex, qui renvoient un seul élément trouvé, et some et every, qui renvoient un booléen.

Intercepte les exceptions avec try et catch, place le code qui doit toujours s'exécuter dans finally, relance une exception vers l'appelant avec throw et distingue les types avec instanceof.

Lève une exception avec throw new Error là où tu trouves une valeur invalide, définis tes propres types avec extends Error, vérifie les instanceof dans le bon ordre et conserve l'exception d'origine avec cause.

Découvre les états pending, fulfilled et rejected d'une Promise, une fonction delay qui enveloppe setTimeout, le traitement des résultats avec then / catch / finally, les chaînes de then et l'exécution simultanée avec Promise.all.

Présente les fonctions async, qui renvoient une Promise quand on les appelle, et l'attente avec await ; la gestion des rejets avec try / catch ; la différence entre des await en série et Promise.all en parallèle ; et le piège d'un await oublié, qui laisse une Promise dans ta variable.

Présente les générateurs, qui s'arrêtent à chaque yield en renvoyant des valeurs, et la façon dont next() les fait avancer ; le protocole itérateur sur lequel repose for...of ; la conversion en tableau avec le spread et l'état qui reste ensuite ; et l'évaluation paresseuse pour ne prendre que le nécessaire dans une suite sans fin.

Un récapitulatif en tableaux : choisir une méthode de tableau selon la forme de son retour, savoir quand on peut continuer une chaîne, les trois façons d'attendre (callbacks, then et await), et l'endroit où sont interceptés un throw synchrone et une Promise en échec.

Comment une classe permet de créer beaucoup d'objets de même forme : les instances avec constructor et new, les méthodes qui utilisent this, et quand un littéral objet suffit.

Le constructor et les champs de classe, qui fixent les valeurs initiales d'une instance : recevoir les arguments, l'ordre des champs, les valeurs par défaut et le rejet des valeurs invalides.

Comment static donne des valeurs et des méthodes à la classe elle-même : compteurs en champs static, fabriques à partir de JSON, constantes partagées et choix face aux membres d'instance.

Exécuter du code à la lecture ou à l'affectation d'une propriété : propriétés calculées, validation, setter appelé dans le constructor et lecture seule.

Les champs et méthodes privés en # sont inaccessibles hors de la classe. Au programme : la SyntaxError levée avant l'exécution et la différence avec la convention _.

L'héritage, qui crée une nouvelle classe à partir d'une classe existante : la syntaxe extends, l'appel à super() dans le constructor de la classe enfant, la redéfinition de méthode et super.nomDeMethode() pour appeler la méthode du parent.

Le polymorphisme, où chaque classe reçoit une méthode du même nom pour que l'appelant n'ait qu'une seule façon d'écrire l'appel : appeler d'un coup tout un tableau mélangé, les cas où tester avec instanceof, et le duck typing pour les valeurs qui n'héritent pas.

Comment this est déterminé quand tu extrais une méthode ou la passes en callback : la TypeError, bind, les champs en fonction fléchée et setTimeout.

Le prototype, là où sont rangées les méthodes d'une classe, et la chaîne de prototypes, l'ordre dans lequel les noms sont cherchés : Object.getPrototypeOf, la différence entre hasOwnProperty et in, et comment ajouter des fonctions.

toString, toJSON et Symbol.iterator, que JavaScript appelle dans des situations précises : décider de l'affichage d'un objet, choisir les valeurs qui partent dans le JSON, et rendre une classe parcourable avec for...of.

export rend publiques les valeurs d'un fichier, import les charge : la différence entre exports nommés et export par défaut, type="module" dans le navigateur, et comment distinguer ESM et CommonJS dans Node.js.

La composition découpe les fonctionnalités en briques assemblées dans un seul objet : ajout après coup avec Object.assign, fonctions qui renvoient une brique combinées à la syntaxe de décomposition, fonctions mixins qui empilent des fonctionnalités sur une classe, et quand préférer l'héritage.

Des tableaux récapitulatifs qui classent la syntaxe des classes selon l'emplacement de chaque membre, montrent quelle définition s'exécute avec extends et super, la valeur de this selon la façon d'appeler, la portée d'une fonctionnalité selon l'héritage, le prototype ou la composition, et le moment où une erreur arrête le code.

Comment le navigateur construit le DOM à partir du HTML, dans quel ordre il traite link et script, l'attribut defer, la console des DevTools et la vérification des résultats en texte dans la console des exercices.

querySelector et querySelectorAll pour récupérer des éléments dans l'arbre DOM. Apprends à chercher par class, id et attribut data, à convertir une NodeList en tableau et à utiliser ?. quand rien n'est trouvé.

createElement et append pour ajouter des éléments, remove pour les retirer, classList et dataset pour les classes et les attributs, et la différence entre textContent et innerHTML pour afficher une saisie en texte brut.

addEventListener pour appeler une fonction au clic et event.target pour l'élément cliqué, la délégation d'événements grâce au bubbling vers les parents, stopPropagation, et le retrait des écouteurs avec once et removeEventListener.

value et checked pour lire les champs, les événements input et change déclenchés par la saisie, submit et preventDefault pour annuler un envoi, et FormData pour rassembler tous les champs d'un coup.

fetch et json() pour récupérer du JSON depuis une URL, response.ok pour repérer un échec, les URL relatives et Promise.all pour charger deux fichiers à la fois.

Les erreurs HTTP sur lesquelles fetch ne lève rien, les erreurs réseau où fetch échoue lui-même, le timeout avec AbortController et setTimeout, et un seul nouvel essai.

setItem, getItem et removeItem pour enregistrer des valeurs dans le navigateur avec localStorage, les tableaux stockés en JSON puisque les valeurs deviennent des chaînes, le null d'une clé absente et la limite de taille.

Découvre comment appeler une fonction plus tard avec setTimeout, arrêter setInterval, créer un Date et ses mois comptés à partir de 0, afficher une date avec Intl.DateTimeFormat et calculer un écart en jours.