• 199 € ou 5 paiements mensuels de 39,80 €

Module avancé

Maîtrise le JavaScript en apprenant les concepts avancés du langage et la programmation moderne ES2024.

Ce module est le dernier module qu'il est nécessaire de suivre pour avoir une maîtrise suffisante du langage JavaScript pour postuler avec confiance à un emploi de développeur junior. Grâce à ce module tu produiras du code moderne et concis lors des entretiens techniques pour valoriser ton profil et décrocher ton premier job.

Prérequis

Tu devras avoir suivi les modules débutant et intermédiaire.

Avoir suivi le module algorithmique n'est pas obligatoire mais fortement recommandé si ta logique pêche un peu. En effet je ne m'attarderai pas sur les explications des algorithmes que nous utiliserons dans ce module car il y aura déjà beaucoup de choses à dire sur les nouvelles fonctionnalités du JavaScript !

Objectifs de ce module

  • Maîtriser le langage JavaScript moderne

  • Connaître les avantages et inconvénients des différentes façons de faire la même chose avec ce langage pour choisir la bonne façon de faire selon ton contexte

  • Savoir lire et moderniser du code legacy pour te préparer au monde de l'entreprise

Le code legacy

Lorsqu'on décroche son premier job en entreprise, il est rare de travailler sur du code neuf ou de développer à partir de zéro le produit ou service que l'entreprise vend.

En général, on travaille sur une base de code déjà existante que les clients utilisent au quotidien. C'est ce code qui tourne sur les serveurs accessibles au public et qui délivre le service vendu par l'entreprise. C'est ce qu'on appelle du code en production.

Une grande partie de ce code est très souvent vieux car développé initialement il y a plusieurs années par une petite équipe à la naissance de l'entreprise. Il peut être mal maintenu ou rafistolé dans tous les sens. Il utilise même de vieilles technologies parfois, de vieilles versions des outils ou du langage lui-même (ES5 avec le mot-clé var par exemple etc.).

On qualifie ce code de code legacy (legacy signifie héritage en français).

Le but d'une entreprise est de faire de l'argent, pas d'avoir le code source le plus propre et moderne du monde*. En effet le client final s'en moque tant que le service fonctionne.

En règle général, tu risques de rencontrer du vieux code qu'il faudra comprendre et savoir moderniser, c'est l'un des objectifs de ce module. Toutes les formations qui enseignent le JavaScript t'expliquent comment écrire du JavaScript moderne ES6+ mais aucune ne t'apprend à lire et comprendre du vieux code.

Pourtant c'est indispensable pour travailler d'une part sur du code legacy en entreprise et pour comprendre d'autre part les évolutions du langage.

Dans ce module, tu apprendras à lire et à moderniser du code legacy ce qui te permettra de comprendre (et d'apprendre) pourquoi et d'où viennent les nouveautés apportées au langage JavaScript dans les versions ES6 et suivantes.

Grâce à de nombreux exemples on verra les avantages à utiliser du code moderne dans nos programmes et les différences parfois subtiles qu'il y a entre un vieux code et un nouveau écrit en ES6+.

---
* Maintenir du code legacy et développer de nouvelles fonctionnalités par dessus engendre des coûts de maintenance croissants dans le temps. On délivre de moins en moins vite de nouvelles fonctionnalités aux clients et le produit devient plus lent, moins performant et souvent bogué, ce qui fait perdre de l'argent à l'entreprise.

Celles-ci ont enfin pris conscience de ce problème important et certaines mettent en place des outils et des techniques de développement modernes pour maintenir le code de leur produit ou service : tests unitaires, fonctionnels, intégration continue, architecture logicielle adaptée, etc. pour permettre de délivrer fréquemment un code moderne de qualité (et non bogué !) à leurs clients.

C'est pour ça que la culture software craftsmanship, les méthodes agiles, la programmation fonctionnelle et tout un tas d'autres méthodes modernes deviennent de plus en plus utilisées en entreprise : faire du code propre et moderne rapporte de l'argent sur le long terme.

Malheureusement, le nombre d'entreprises ayant les moyens financiers (mais surtout la volonté !) d'emprunter cette voie reste faible par rapport aux autres. C'est pourquoi ce module vous préparera à travailler sur du code legacy pour vous permettre de vous adapter à un environnement hostile 😉.

Quel est le "bon" code ?

Deuxième objectif de ce module : te fournir les connaissances nécessaires pour pouvoir faire toi-même le choix du bon outil à utiliser selon ton contexte. En effet, en JavaScript, il est possible de rédiger plusieurs codes sources différents qui font la même chose. Mais alors, lequel choisir ? Quel est le "bon" ?

On verra dans ce module les avantages, les inconvénients et surtout les différences entre les anciennes instructions et les instructions modernes proposées par ce langage.

Le contexte dans lequel on travaille va souvent jouer un rôle majeur dans le choix de l'instruction à utiliser en JavaScript. Par exemple : pourquoi et quand préférer une boucle for...of à la méthode forEach sur un tableau ? Quelles différences si je choisis l'une ou l'autre façon de faire ?

Une garantie satisfait ou remboursé

La formation JavaScript de Zéro est disponible avec une garantie "satisfait ou remboursé" de 14 jours, qui te permet d’obtenir un remboursement si tu n’es pas satisfait de la qualité de la formation ou de son contenu. Tu ne prends donc aucun risque à l'acheter dès maintenant.

Sommaire des leçons

Le contenu est en cours de création.

Introduction

Le contenu de ce module est en cours de création.
C'est l'heure !
    La valeur -0 et Object.is()
    • 18 min
    • 167 Mo
    Les timestamps
    • 11 min
    • 81,8 Mo
    Le format JSON
    • 22 min
    • 192 Mo

    Type de données

    Le type BigInt
    • 25 min
    • 255 Mo
    Quiz #1

      De nouveaux opérateurs

      Les courts-circuits
      • 17 min
      • 149 Mo
      L'opérateur de coalescence des nuls
      • 14 min
      • 136 Mo
      L'opérateur de chaînage optionnel
      • 29 min
      • 290 Mo
      Aperçu
      Exercices remaniement de code
      • 4 min
      • 33,5 Mo

      Les boucles

      La méthode forEach()
      • 21 min
      • 199 Mo
      Les boucles for...of
      • 7 min
      • 56 Mo
      Les boucles for...in
      • 7 min
      • 59,5 Mo
      Quelle façon de boucler choisir ?
      • 6 min
      • 51,5 Mo

      Autres opérateurs

      L'opérateur in
      • 9 min
      • 78,5 Mo
      L'opérateur virgule
      • 10 min
      • 73,8 Mo

      Gestion des erreurs

      La syntaxe try... catch
      • 7 min
      • 63,7 Mo

      Les tableaux

      La méthode filter()
      • 19 min
      • 179 Mo
      On recode filter() de zéro !
      • 12 min
      • 120 Mo
      La méthode map()
      • 13 min
      • 122 Mo
      On recode map() de zéro !
      • 5 min
      • 53,4 Mo
      La méthode reduce()
      • 27 min
      • 305 Mo
      On recode reduce() de zéro !
      • 10 min
      • 111 Mo
      Choisir entre filter(), map() et reduce()
      • 17 min
      • 192 Mo
      Le chaînage de méthodes
      • 15 min
      • 147 Mo
      La méthode some()
      • 8 min
      • 81,6 Mo
      Précision sur some() et every()
      • 2 min
      • 19,5 Mo
      La méthode every()
      • 7 min
      • 76,9 Mo
      La méthode at()
      • 6 min
      • 59,8 Mo
      Challenge : recodez some() et every() !
      • 2 min
      • 12,9 Mo
      Solution au challenge
      • 7 min
      • 71,7 Mo

      Les objets

      Nouveautés ES6 sur les objets
      • 9 min
      • 76,3 Mo
      Accesseurs de propriétés (Getters et Setters)
      • 10 min
      • 94,6 Mo

      Types de données avancés

      Avant-propos
        Introduction au ramasse-miettes (garbage collector)
        • 13 min
        • 106 Mo
        Aperçu
        WeakMap et WeakSet
        • 18 min
        • 173 Mo
        Aperçu
        TypedArray
        • 15 min
        • 33,6 Mo
        Les symboles
        • 15 min
        • 39,3 Mo
        Les itérables et itérateurs
        • 21 min
        • 62,1 Mo

        La décomposition (destructuring)

        Assignation par décomposition de tableaux
        • 20 min
        • 189 Mo
        Décomposition et itérateurs
        • 17 min
        • 166 Mo
        Assignation par décomposition d'objets
        • 12 min
        • 123 Mo
        L'opérateur spread
        • 14 min
        • 128 Mo

        Les fonctions

        Qu'est-ce que le hoisting ?
        • 17 min
        • 182 Mo
        Valeurs par défaut des paramètres
        • 10 min
        • 85 Mo
        Décomposition dans les paramètres de fonctions
        • 13 min
        • 151 Mo
        Fonctions variadiques (paramètres du reste)
        • 9 min
        • 85,8 Mo
        Nouvelle syntaxe de définition d'une méthode
        • 3 min
        • 21 Mo
        Le mot-clé this
        • 16 min
        • 158 Mo
        Les fonctions fléchées
        • 17 min
        • 151 Mo
        Les fonctions fléchées et this
        • 7 min
        • 56,1 Mo
        thisArg et les méthodes sur les tableaux
        • 10 min
        • 91 Mo
        Les méthodes call() apply() et bind()
        • 15 min
        • 144 Mo
        Les fonctions imbriquées
        • 3 min
        • 18,3 Mo
        La portée lexicale
        • 11 min
        • 101 Mo
        Aperçu
        Les closures
        • 10 min
        • 77,2 Mo
        Aperçu
        Les closures : exemple supplémentaire
        • 7 min
        • 66,5 Mo
        Aperçu
        IIFE
        • 9 min
        • 63,2 Mo
        Les générateurs
        • 13 min
        • 125 Mo

        L'héritage par prototypes

        Préambule
          Introduction
          • 4 min
          • 36 Mo
          Les prototypes
          • 20 min
          • 210 Mo
          Les fonctions constructeurs
          • 10 min
          • 103 Mo
          Constructeurs et prototypes
          • 16 min
          • 193 Mo
          Propriétés et méthodes statiques
          • 5 min
          • 45,5 Mo
          Object.create()
          • 3 min
          • 21,4 Mo
          Ce qu'il faut retenir
          • 7 min
          • 71,1 Mo
          Exemple d'héritage
          • 13 min
          • 133 Mo

          Les classes

          Les classes
          • 11 min
          • 134 Mo
          Classes VS Constructeurs
          • 3 min
          • 34,9 Mo
          Les classes sont des fonctions
          • 5 min
          • 43,6 Mo

          Les modules

          Le mode strict
          • 16 min
          • 150 Mo
          Introduction aux modules
          • 5 min
          • 36,5 Mo
          Les modules CommonJS
          • 11 min
          • 105 Mo
          Modules ES6
          • 13 min
          • 188 Mo
          CommonJS VS Modules ES6
          • 5 min
          • 48 Mo
          Exemple module ES6 dans un site web
          • 4 min
          • 26,8 Mo
          Utiliser un package npm
          • 5 min
          • 46,3 Mo
          Remaniement de code
          • 32 min
          • 485 Mo

          Le JavaScript asynchrone

          Les débuts du web
          • 5 min
          • 58,1 Mo
          XMLHttpRequest
          • 8 min
          • 86 Mo
          Callback hell
          • 9 min
          • 130 Mo
          Les promesses
          • 30 min
          • 348 Mo
          Projet API GitHub avec les promesses
          • 11 min
          • 157 Mo
          Projet API GitHub avec fetch
          • 14 min
          • 172 Mo
          Comment mixer les modules ESM et CommonJS ?
          • 18 min
          • 207 Mo
          La syntaxe async await
          • 22 min
          • 238 Mo

          Fin du module

          Derniers conseils
          • 4 min
          • 36,9 Mo

          Une question ? Contacte-moi !

          ➡️ Par téléphone ou WhatsApp : 06 67 40 56 09
          ➡️ Par email : jeremy@javascriptdezero.com