Formation : TypeScript pour les développeurs JavaScript

• Développeurs JavaScript maîtrisant ES6+ souhaitant sécuriser leur code avec le typage statique.
• Développeurs React voulant typer leurs composants, props et hooks pour réduire les bugs en production.
• Développeurs autodidactes ou en reconversion souhaitant adopter les standards professionnels des équipes front-end modernes.
• Personnes ayant suivi la formation JavaScript fondamentaux ou disposant d'une expérience JavaScript équivalente.

• Comprendre l'intérêt du typage statique et ce que TypeScript apporte concrètement par rapport à JavaScript
• Maîtriser les types de base, les interfaces et les types littéraux
• Distinguer interface et type alias et savoir choisir entre les deux
• Utiliser les generics pour écrire du code réutilisable et fortement typé
• Typer les props, les états et les hooks dans un projet React
• Utiliser les utility types : Partial, Required, Omit, Pick, Record, ReturnType
• Configurer tsconfig.json selon le contexte du projet
• Migrer un projet JavaScript existant vers TypeScript de manière progressive

• Bonne maîtrise de JavaScript ES6+ : fonctions fléchées, destructuring, modules, classes. 
• La formation JavaScript fondamentaux ou équivalent est requise. 
• Des notions de React sont appréciées pour les modules dédiés aux composants. 
• Savoir utiliser le terminal et VS Code.

• Les limites de JavaScript à grande échelle : bugs silencieux, refactoring risqué
• Ce que le typage statique apporte : autocomplétion, détection d'erreurs à la compilation
• TypeScript vs JavaScript : transpilation, compatibilité, courbe d'adoption
• TypeScript dans l'écosystème : React, Node.js, Next.js, Angular

• Installer TypeScript et ts-node
• Compiler avec tsc : options essentielles
• Configurer tsconfig.json : strict, target, module, paths
• Intégrer TypeScript dans un projet Vite existant
• Lire et interpréter les erreurs de compilation

• string, number, boolean, null, undefined, any, unknown, never, void
• Inférence de type : quand TypeScript devine le type automatiquement
• Pourquoi éviter any et comment le remplacer par unknown
• Cas pratique : typer des variables et des valeurs de retour de fonctions simples

• Paramètres typés, valeur de retour explicite
• Paramètres optionnels et valeurs par défaut
• Rest parameters et tuples
• Function overloading : définir plusieurs signatures pour une même fonction
• Cas pratique : bibliothèque utilitaire entièrement typée

• Object types inline : définir la forme d'un objet directement
• Propriétés optionnelles et propriétés readonly
• Tableaux typés : Array et la syntaxe T[]
• Tuples : tableaux à longueur et types fixes
• Cas pratique : modéliser une entité utilisateur avec ses propriétés obligatoires et optionnelles

• Déclarer une interface : syntaxe et conventions de nommage
• Déclarer un type alias : cas d'usage spécifiques
• Les différences clés : extension, fusion de déclarations, unions
• La règle pratique : quand choisir l'un ou l'autre
• Cas pratique : modéliser les entités d'une application e-commerce

• Étendre une interface avec extends
• Intersection types : combiner plusieurs types avec &
• Union types : accepter plusieurs types possibles avec |
• Discriminated unions : pattern pour distinguer des variantes d'un type
• Cas pratique : système de notifications avec types de message distincts

• Enums numériques et string enums
• Les limites des enums et les alternatives modernes
• Types littéraux : restreindre une valeur à un ensemble fini
• Const assertions : as const pour inférer des types précis
• Cas pratique : statuts d'une commande avec union de littéraux

• Exercices de modélisation : concevoir les types d'une application de A à Z
• Correction collective et analyse des erreurs fréquentes
• Questions et approfondissement selon les besoins du groupe

• Le problème que les generics résolvent : code réutilisable sans perdre le typage
• Syntaxe de base : fonctions génériques, types génériques
• Contraindre un generic avec extends
• Plusieurs paramètres de type : T, U, K, V
• Cas pratique : fonction de tri générique et wrapper de réponse API

• Generics avec interfaces et classes
• Valeurs par défaut pour les paramètres de type
• keyof et types indexés : accéder aux clés d'un objet de manière typée
• Conditional types : T extends U ? X : Y
• Cas pratique : hook générique useFetch avec typage de la réponse

• Partial : rendre toutes les propriétés optionnelles
• Required : rendre toutes les propriétés obligatoires
• Readonly : interdire la modification des propriétés
• Pick : extraire un sous-ensemble de propriétés
• Omit : exclure des propriétés d'un type existant
• Cas pratique : formulaire de mise à jour partielle d'un utilisateur

• Record : créer un dictionnaire typé clé/valeur
• Exclude et Extract : filtrer des unions de types
• NonNullable : retirer null et undefined d'un type
• ReturnType et Parameters : inférer les types depuis une fonction existante
• Cas pratique : typer un store Redux ou une configuration d'API sans duplication

• Typer les props avec une interface : syntaxe et conventions
• React.FC vs typage direct : pourquoi préférer le typage direct
• La prop children : React.ReactNode vs React.PropsWithChildren
• Les événements React : MouseEvent, ChangeEvent, FormEvent
• Cas pratique : composant Button générique avec variants typés

• useState avec un type explicite : useState<T>
• useRef : HTMLElement, RefObject vs MutableRefObject
• useReducer : typer l'état et les actions avec discriminated unions
• useContext : créer un contexte fortement typé
• Cas pratique : hook personnalisé useForm avec typage générique

• Migrer un projet React JS vers TypeScript : stratégie progressive fichier par fichier
• Intégrer TypeScript dans un projet Next.js : next.config.ts, types Next.js
• Les fichiers de déclaration .d.ts : à quoi ils servent et quand en créer
• Installer les types manquants avec @types/...
• Les règles tsconfig strict les plus importantes : noImplicitAny, strictNullChecks
• Cas pratique : migrer un composant React existant et corriger les erreurs de type

• Cahier des charges : migrer une application React existante avec composants, hooks personnalisés, contexte et appels API
• Étape 1 : mise en place de tsconfig.json et renommage des fichiers
• Étape 2 : typage des entités métier avec interfaces et types
• Étape 3 : typage des composants, props et événements
• Étape 4 : typage des hooks et du contexte global
• Revue de code collective : choix de types, lisibilité, absence de any
• Retour formateur individualisé sur le projet rendu

• Écrire du TypeScript idiomatique dans un projet React ou Node.js
• Concevoir des types et interfaces adaptés à la structure des données métier
• Exploiter l'autocomplétion et les erreurs de compilation pour produire un code plus fiable
• Utiliser les utility types pour transformer et composer des types existants
• Configurer et intégrer TypeScript dans un projet Vite ou Next.js
• Migrer progressivement une base de code JavaScript vers TypeScript sans bloquer la production

• En cours de formation : exercices de typage progressifs corrigés à chaque module
• En fin de formation : migration d'un composant React JavaScript vers TypeScript avec correction de toutes les erreurs de compilation
• Questionnaire d'auto-évaluation des acquis en fin de parcours

• Choix pertinent entre interface et type alias selon le contexte
• Utilisation correcte des generics pour éviter la duplication de types
• Typage complet des props et hooks React sans recours à any
• Application adaptée des utility types pour transformer des types existants
• Configuration tsconfig.json cohérente avec le niveau de rigueur attendu en production

Cette formation a été créée en 2026. Les indicateurs de résultats (taux de satisfaction, taux d’atteinte des objectifs, taux d’assiduité) seront publiés sur cette page à l’issue des premières sessions réalisées.

• Support de cours numérique mis à disposition des apprenants
• Dépôt GitHub de démonstration avec exercices et corrections par module
• Environnement de développement : VS Code + TypeScript + Vite
• Pour le distanciel : visioconférence (Zoom ou équivalent), partage d'écran, chat en direct
• Accès à la plateforme pédagogique LaPolaris (supports, ressources, émargement)

• Feuilles d'émargement signées par demi-journée (présentiel) ou émargement numérique (distanciel)
• Traçabilité des activités pédagogiques réalisées
• Attestation d'assiduité délivrée en fin de formation
• Suivi individuel via les exercices corrigés et le projet de migration