TypeScript - Développer des applications JavaScript robustes

Objectif : Comprendre les limites de JavaScript et la valeur ajoutée de TypeScript. Installer l'environnement de développement et configurer finement le compilateur TypeScript (tsc). Maîtriser le typage des types primitifs et des tableaux.

• Introduction à l'écosystème TypeScript : transpilation vs compilation.
• Initialisation d'un projet : création et paramétrage du fichier tsconfig.json (règles de rigueur comme strict, noImplicitAny).
• Les types primitifs (string, number, boolean, any, unknown, void, never).
• Typage des collections : tableaux simples, tableaux multidimensionnels et tuples.

Atelier pratique : Initialisation d'un projet de A à Z avec VS Code, configuration du compilateur, écriture et transpilation réussie des premiers fichiers d'applications.

Cas métier : Développement d'un module de nettoyage et de validation d'un catalogue de produits (importation de données brutes corrompues d'un fournisseur).

Compétence acquise : Savoir initialiser et configurer un projet TypeScript robuste et maîtriser les types élémentaires.

Livrable : Un projet de base de code sain, configuré en mode strict et prêt pour le développement d'entreprise.

Objectif : Sécuriser l'écriture des fonctions en typant les paramètres et les valeurs de retour. Créer des structures d'objets complexes et réutilisables à l'aide des interfaces et des alias de types (type). Implémenter les notions de propriétés optionnelles et en lecture seule.

• Typage précis des fonctions : paramètres obligatoires, optionnels, valeurs par défaut et fonctions anonymes.
• Déclaration d'alias de types personnalisés (type User = ...) vs Déclaration d'interfaces (interface User { ... }).
• Gestion des objets : propriétés optionnelles ( ? ) et propriétés immuables (readonly).
• Combinaisons de types : Unions (type1 | type2) et intersections (type1 & type2).

Atelier pratique : Création de structures complexes interconnectées et écriture de fonctions de traitement métier fortement typées.

Cas métier : Conception d'un moteur de validation de transactions bancaires (analyse d'objets virements, prélèvements et comptes avec différents niveaux de droits d'accès).

Compétence acquise : Être capable de modéliser et de typer avec précision les structures de données complexes d'un domaine métier.

Livrable : Un ensemble de types et de contrats d'interfaces fiabilisés, empêchant toute incohérence de données.

Objectif : Implémenter le paradigme orienté objet à l'aide des classes TypeScript. Maîtriser les modificateurs d'accès (public, private, protected, readonly) pour assurer l'encapsulation. Organiser le code de manière modulaire à l'aide des imports/exports TypeScript.

• Différences entre les classes ES6 JavaScript et les classes TypeScript.
• Les modificateurs d'accès et le raccourci de déclaration dans le constructeur (Parameter Properties).
• L'implémentation d'interfaces par des classes (implements) et le concept d'héritage (extends).
• Les classes et méthodes abstraites (abstract) pour structurer des architectures réutilisables.
• Modularité du code : systèmes d'import/export de types et de valeurs.

Atelier pratique : Écriture de classes métiers complexes, mise en place d'héritage et séparation du code dans une architecture modulaire claire.

Cas métier : Modélisation d'un système de gestion d'utilisateurs et de droits d'accès (Administrateur, Client, Invité) avec encapsulation stricte des mots de passe et jetons.

Compétence acquise : Savoir construire des architectures logicielles structurées, orientées objet et modulaires avec TypeScript.

Livrable : Une architecture modulaire de classes métiers interconnectées et encapsulées.

Objectif : Concevoir du code réutilisable et flexible grâce aux types génériques (Generics). Mettre en œuvre des mécanismes de protection de types dynamiques (Type Guards et Type Assertions). Apprendre à intégrer TypeScript dans un projet JavaScript existant ou à utiliser des librairies tierces non typées.

• Introduction aux Generics : syntaxe et intérêt pour les fonctions, classes et interfaces réutilisables.
• Protection de types dynamique : utilisation de typeof, instanceof et de fonctions de validation personnalisées (Type Predicates).
• Les assertions de types (as type) et leur utilisation sécurisée.
• Utilisation de bibliothèques tierces : gestion des fichiers de définition de types (@types/...).

Atelier pratique : Écriture de fonctions utilitaires génériques, mise en place d'un typage pour une API externe et refactoring d'un module JavaScript historique.

Cas métier : Création d'une bibliothèque d'appels API générique capable de requêter et de typer automatiquement n'importe quelle ressource du système (Utilisateurs, Commandes, Produits).

Compétence acquise : Maîtriser les rouages avancés de TypeScript pour concevoir des utilitaires hautement réutilisables et interopérables.

Livrable : Un moteur de requêtage universel et auto-typé, prêt pour la mise en production.