Module 1 — Comprendre les apports de TypeScript dans un projet
- Positionnement de TypeScript par rapport à JavaScript et enjeux du typage statique.
- Différences entre typage dynamique, inférence et typage explicite.
- Bénéfices concrets sur la robustesse, la lisibilité et la maintenabilité du code.
- Cas d’usage courants en front-end, back-end et projets full-stack.
- Identification des limites, contraintes et points de vigilance dans l’adoption de TypeScript.
Module 2 — Maîtriser les fondamentaux du typage
- Déclarer et utiliser les types primitifs, tableaux, tuples, enums et littéraux.
- Typage des variables, objets, paramètres et valeurs de retour.
- Comprendre l’inférence de type et savoir quand expliciter les annotations.
- Utiliser les unions, intersections et types optionnels pour modéliser des cas variés.
- Sécuriser les manipulations de données avec le typage strict et les vérifications adaptées.
- Mise en application encadrée sur des exemples de données et de fonctions usuelles.
Module 3 — Structurer les objets et contrats avec interfaces et alias
- Définir des interfaces claires pour décrire des structures de données cohérentes.
- Utiliser les alias de types selon les besoins de lisibilité et de réutilisation.
- Gérer les propriétés optionnelles, en lecture seule et les signatures dynamiques.
- Étendre et composer des contrats de type pour mutualiser les définitions.
- Choisir entre interface et type selon le contexte technique et métier.
- Améliorer la stabilité des échanges entre modules grâce à des contrats explicites.
Module 4 — Sécuriser les fonctions et les flux de données
- Typer précisément les fonctions, callbacks, objets retournés et fonctions asynchrones.
- Manipuler correctement les paramètres optionnels, par défaut et restants.
- Utiliser les type guards, le narrowing et les contrôles conditionnels pour fiabiliser l’exécution.
- Encadrer les valeurs inconnues avec unknown plutôt que any lorsque c’est pertinent.
- Réduire les effets de bord et clarifier les responsabilités des fonctions.
- Mise en application encadrée sur des scénarios de validation et de transformation de données.
Module 5 — Concevoir une architecture plus lisible avec classes, modules et génériques
- Utiliser les classes, constructeurs, propriétés et modificateurs d’accès de manière pertinente.
- Comprendre les apports de l’orienté objet dans certains contextes de structuration.
- Organiser le code en modules pour améliorer la séparation des responsabilités.
- Exploiter les génériques pour créer des composants réutilisables et sûrs.
- Concevoir des abstractions adaptées sans complexifier inutilement le code.
- Évaluer les choix d’architecture selon la taille, la durée de vie et les usages du projet.
Module 6 — Configurer TypeScript et l’intégrer dans l’environnement de développement
- Lire et ajuster les principales options du fichier tsconfig.json.
- Comprendre l’impact des modes stricts sur la qualité et la détection d’erreurs.
- Organiser la compilation, l’émission de fichiers et les chemins de résolution.
- Intégrer TypeScript avec les outils de build, bundlers, linters et tests.
- Gérer la compatibilité avec des bibliothèques JavaScript existantes et leurs définitions de types.
- Sécuriser le workflow de développement avec des réglages cohérents et partagés.
Module 7 —Faire évoluer un code JavaScript vers TypeScript
- Identifier les stratégies de migration progressive d’un projet existant.
- Prioriser les zones de code sensibles ou à forte valeur pour le typage.
- Introduire TypeScript sans bloquer la production ni dégrader l’expérience de développement.
- Traiter les fichiers mixtes, les dépendances externes et les cas de typage incomplet.
- Corriger les erreurs fréquentes rencontrées lors d’une transition vers un code plus strict.
- Mise en application encadrée sur des extraits de code JavaScript à fiabiliser.
Module 8 — Adopter les bonnes pratiques de qualité et de maintenance
- Éviter les usages abusifs de any, les assertions excessives et les contournements du typage.
- Nommer, factoriser et documenter les types pour améliorer la compréhension collective.
- Mettre en place des conventions favorisant la relecture et la cohérence d’équipe.
- Détecter les signes d’un modèle de types trop complexe ou insuffisamment maîtrisé.
- Améliorer la maintenabilité du code grâce à une structure claire et des responsabilités explicites.
- Consolider les acquis à travers des exercices d’analyse, de correction et d’optimisation encadrés.
