Cours JavaScript

Les fondements : déclarer des variables, reconnaître des types, effectuer des opérations arithmétiques et prendre des décisions.

1. 1.1Variables : let et constDéclarer des valeurs, choisir entre const et let, comprendre la portée de base.~8 min
2. 1.2Types primitifsstring, number, boolean, null, undefined : les blocs de construction du langage.~8 min
3. 1.3OpérateursOpérateurs arithmétiques, de comparaison, logique booléenne et priorité des opérateurs.~10 min
4. 1.4Conditionnels : if, else, ternaireExécuter un code différent selon la valeur d'une expression.~10 min

Les deux types les plus utilisés : composer du texte avec des littéraux de gabarits, le manipuler avec des méthodes de chaîne, faire de l'arithmétique avec les nombres et Math.

1. 2.1Chaînes et littéraux de gabaritsGuillemets, échappements, accents graves et interpolation ${...} pour composer du texte.~8 min
2. 2.2Méthodes de chaînelength, toUpperCase, includes, slice, split, replace : les méthodes que vous utilisez tous les jours.~10 min
3. 2.3Nombres et MathEntiers et décimaux, arrondi, Math.min/max/round/floor/ceil, Math.random.~10 min
4. 2.4Conversions de typeNumber, String, parseInt, parseFloat, toFixed et quand NaN vous piège.~8 min

Les deux structures de données les plus utilisées : listes ordonnées (tableaux) et tables de hachage (objets).

1. 3.1Tableaux : la liste ordonnéeCréer un tableau, lire/écrire par index, push/pop/shift/unshift, length.~10 min
2. 3.2Objets : la table de hachageLittéraux, accès par point et crochet, ajout/suppression de propriétés.~10 min
3. 3.3Déstructuration et spreadExtraire plusieurs valeurs en une seule ligne; copier et fusionner des tableaux et des objets avec `...`.~12 min
4. 3.4Itérer sur des collectionsfor…of sur les tableaux, for…in sur les objets, Object.keys/values/entries.~10 min

Décomposez vos programmes en éléments réutilisables : déclarez-les, écrivez-les de manière compacte avec des flèches, transmettez des paramètres flexibles et comprenez les fermetures.

1. 4.1Déclarer une fonctionDéclaration de fonction vs expression de fonction, paramètres, retour.~10 min
2. 4.2Funciones flechaSyntaxe compacte `=>`, corps concis vs bloc, retour implicite.~10 min
3. 4.3Paramètres par défaut et restValeurs par défaut, `...rest` pour un nombre variable d'arguments, spread lors de l'appel.~12 min
4. 4.4Fermetures et portéeFonctions qui se souviennent de leur environnement : compteurs, usines, chaîne de portée.~12 min

Répéter, sauter, gérer les erreurs : les structures qui permettent à votre code de réagir aux données et aux problèmes.

1. 5.1Boucles : for et whilefor classique, while, do…while : répéter jusqu'à une condition.~10 min
2. 5.2for…of et for…inIterer sur les valeurs d'une collection vs les clés d'un objet. Quand utiliser lequel.~10 min
3. 5.3break et continueQuitter une boucle plus tôt, ou passer à l'itération suivante.~10 min
4. 5.4try / catch / throwLever et capturer des erreurs, séparer le flux normal du flux exceptionnel.~12 min

Les méthodes qui transforment les tableaux : map pour modifier chaque élément, filter pour sélectionner, reduce pour agréger, find/some/every pour rechercher, sort pour trier.

1. 6.1map et filterTransformer chaque élément (map) et sélectionner un sous-ensemble (filter).~10 min
2. 6.2reduceAgréger un tableau en une seule valeur : sommes, comptes, cartes.~12 min
3. 6.3find, some, everyTrouver le premier, vérifier si au moins un ou tous satisfont à un prédicat.~10 min
4. 6.4sortTrier un tableau avec un comparateur; tri stable, copie via toSorted.~12 min

Code qui attend : promesses, async/await, appels réseau simulés (fetch) et gestion des erreurs asynchrones.

1. 7.1Promesses : ce qu'elles sontÉtat en attente/résolu/rejeté, .then/.catch, Promise.resolve et reject.~12 min
2. 7.2async / awaitÉcrire du code asynchrone qui se lit comme du code synchrone.~12 min
3. 7.3fetch (simulé)Appeler un point d'accès, lire le JSON, composer les résultats avec Promise.all.~14 min
4. 7.4Erreurs dans le code asynchronetry/catch autour d'await, .catch sur les Promesses, échecs dans Promise.all.~12 min

Rassemblez tous les éléments : organisez le code en modules, analysez un CSV, validez les données d'entrée et planifiez des tâches avec des Promesses.

1. 8.1Modules ESM : import / exportDiviser le code en fichiers et composer des bibliothèques avec export et import (concept).~12 min
2. 8.2Défi : analyseur CSVTransformer une chaîne CSV en un tableau d'objets à l'aide de split, map et déstructuration.~15 min
3. 8.3Défi : validateur de donnéesValider des objets avec des règles composables et collecter toutes les erreurs.~15 min
4. 8.4Défi : planification avec des PromessesExécuter des tâches en série, en parallèle et avec une limite de simultanéité.~15 min