RxJS Programmation réactive
Des bases solides pour maßtriser la programmation réactive
2 j
Fondamental
ANGULAR
Angular
Angular n'est pas qu'un simple framework populaire â c'est l'Ă©pine dorsale des applications web d'entreprise mondialement utilisĂ©es. En 2026, alors que les outils de dĂ©veloppement basĂ©s sur l'IA deviennent essentiels Ă la productivitĂ©, cette formation va au-delĂ de l'enseignement de la syntaxe Angular.
Nos formateurs experts (Google Developers Experts, contributeurs du framework Angular et mainteneurs de NG-ZORRO) vous enseigneront comment exploiter les outils LLM comme Claude pour accélérer votre développement. Mais voici la différence critique : **utiliser un LLM ne signifie pas accepter aveuglément le code généré**. Cette formation insiste sur la compréhension de chaque ligne produite, ce qui vous permet de déboguer, optimiser et maintenir efficacement vos applications.
Que vous soyez développeur frontend ou ingénieur full-stack, vous apprendrez à :
- Créer des applications Angular robustes et évolutives avec les patterns modernes (signaux, composants autonomes, architecture composable)
- Ăcrire des tests avec 100% de couverture pour garantir la maintenabilitĂ© Ă long terme
- Maßtriser l'écosystÚme Angular (injection de dépendances, routage, formulaires, gestion d'état avec NgRx Signal Store)
- Ătre productif avec le dĂ©veloppement assistĂ© par IA tout en maintenant une comprĂ©hension complĂšte de votre codebase
Ă la fin, vous aurez une expĂ©rience pratique avec une application complĂšte de rĂ©pertoire de personnel construite progressivement Ă travers les exercices, vous pourrez passer les certifications Angular Training Level 1 & 2, et surtout â vous obtiendrez l'expertise pour construire des applications prĂȘtes pour la production qui durent.
â Formation officielle SFEIR InstituteNiveau IntermĂ©diaireâ±ïž 4 jours (28h)
Ce que vous allez apprendre
- DĂ©velopper des applications Angular prĂȘtes pour la production avec les patterns modernes
- Exploiter les outils LLM pour la productivité tout en comprenant et en maintenant le code généré
- Ăcrire des tests unitaires complets garantissant 100% de couverture et une maintenabilitĂ© Ă long terme
- Maßtriser l'écosystÚme Angular dans sa globalité (DI, routage, formulaires, gestion d'état, testing)
Prérequis
- JavaScript moderne (scope, arrow functions, classes, notion du 'this', programmation asynchrone avec les promises)
- Connaissances basiques en TypeScript (typage basique, interfaces)
- Compréhension des Observables vs Promises
Public cible
- Développeurs frontend, Développeurs Full-stack JavaScript / Node.js, Développeurs web construisant ou maintenant des applications Angular, Développeurs cherchant à maßtriser Angular moderne avec des workflows assistés par IA
Programme de la Formation
33 modules pour maĂźtriser les fondamentaux
Cours 1 : Jour 1 : Fondations & PremiĂšre Prise en Main avec les Essentiels d'Angular
Objectifs
- Configurer un environnement de développement Angular avec les outils modernes (IDE, CLI, systÚme de build)
- Initialiser de nouveaux projets Angular avec une configuration appropriée et intégration de Material
- Utiliser efficacement les commandes CLI d'Angular pour les workflows de développement quotidiens
Sujets abordés
- âConfiguration de l'IDE : WebStorm vs VS Code
- âInstallation d'Angular et initialisation de projet
- âIntĂ©gration d'Angular Material
- âCommandes CLI et workflow de dĂ©veloppement moderne
- âSystĂšme de build et bundlers
Activités
Bootstrapper une application Angular
Créer votre premier composant avec le CLI
Configurer l'environnement de développement
Objectifs
- Comprendre la structure des composants et créer des composants avec les patterns modernes autonomes
- Utiliser l'interpolation de template et les expressions pour afficher des données dynamiques
- MaĂźtriser le bootstrapping des composants et les phases du cycle de vie
Sujets abordés
- âArchitecture et structure des composants
- âComposants autonomes vs NgModules
- âInterpolation de template et expressions
- âBootstrapping des composants
- âCycle de vie des composants
Activités
Créer des composants imbriqués
Comprendre les bases de la communication entre composants
Objectifs
- Concevoir et construire des structures de composants hiérarchiques pour des applications complexes
- Implémenter les relations parent-enfant et les patterns d'architecture d'application
Sujets abordés
- âConstruire des arbres de composants
- âRelations parent-enfant
- âPatterns d'architecture d'application
Activités
Construire une hiérarchie de composants pour un répertoire du personnel
Objectifs
- Maßtriser le systÚme de réactivité Signal et créer des templates réactifs avec des valeurs calculées
- Appliquer différents types de data binding (interpolation, propriété, événement, bi-directionnel) de maniÚre appropriée
- Optimiser les performances des templates en utilisant les signals et NgOptimizedImage
Sujets abordés
- âSystĂšme de rĂ©activitĂ© avec Signals (signals, computed, effect)
- âTypes de data binding (interpolation, propriĂ©tĂ©, Ă©vĂ©nement, bi-directionnel)
- âDiffĂ©rence entre propriĂ©tĂ© et attribut
- âVariables de template
- âNgOptimizedImage pour les performances
Activités
Afficher des données dynamiques avec signals
Créer des templates réactifs avec le binding approprié
Objectifs
- Gérer les interactions utilisateur et les événements en utilisant efficacement la syntaxe de binding d'événements d'Angular
- Implémenter le binding bi-directionnel avec ngModel pour les contrÎles de formulaire
- Comprendre la propagation d'événements et construire des patterns d'interaction utilisateur réactifs
Sujets abordés
- âSyntaxe du binding d'Ă©vĂ©nements
- âObjets Ă©vĂ©nement et propagation
- âBinding bi-directionnel avec ngModel
- âPatterns d'interaction utilisateur
Activités
Gérer les clics de bouton et les entrées de formulaire
RĂ©agir aux interactions utilisateur avec les signals
Objectifs
- Implémenter les lifecycle hooks des composants pour l'initialisation et le nettoyage
- Gérer les ressources efficacement en utilisant OnDestroy et les patterns de nettoyage appropriés
- Utiliser les patterns d'initialisation basés sur les signals pour les applications Angular modernes
Sujets abordés
- âPhases du cycle de vie des composants
- âHooks OnInit, OnDestroy, OnChanges
- âNettoyage et gestion des ressources
- âPatterns d'initialisation basĂ©s sur les signals
Activités
Implémenter les lifecycle hooks pour l'initialisation des données
Objectifs
- Créer des composants réutilisables en utilisant les décorateurs @Input et @Output
- Implémenter les patterns de communication parent-enfant via les inputs et les événements de sortie
- Utiliser les inputs/outputs basés sur les signals pour la communication de composants moderne et type-safe
Sujets abordés
- âInputs de composants (@Input decorator)
- âOutputs de composants (@Output decorator)
- âPatterns d'Ă©mission d'Ă©vĂ©nements
- âValidation et inputs requis
- âInputs et outputs basĂ©s sur les signals
Activités
Créer des composants personnalisables avec inputs
Construire des patterns de communication parent-enfant
Objectifs
- Utiliser les pipes Angular intégrés pour formater les données dans les templates
- Créer des pipes personnalisés pour étendre la fonctionnalité des templates
- Appliquer efficacement les pipes avec la composition et le chaßnage pour la transformation de données
Sujets abordés
- âPipes built-in (date, currency, uppercase, lowercase, etc.)
- âPipes pures vs impures
- âCrĂ©er des pipes personnalisĂ©s
- âComposition et chaĂźnage de pipes
Activités
Formater des dates et des valeurs avec les pipes
Créer un pipe personnalisé pour les valeurs par défaut
Objectifs
- Créer et utiliser des services avec le systÚme d'Injection de Dépendances d'Angular
- Comprendre l'enregistrement des services et les scopes d'injection pour la fonctionnalité à l'échelle de l'application
- Implémenter les patterns d'initialisation appropriés et les hiérarchies de services
Sujets abordés
- âServices et le @Injectable decorator
- âEnregistrement et providers des services
- âInjecter des services dans les composants
- âScopes d'injection et hiĂ©rarchies
- âPatterns d'initialisation des services
Activités
Créer et utiliser votre premier service
RĂ©aliser une initialisation au niveau de l'application
Objectifs
- Utiliser les directives built-in pour contrĂŽler la structure et le style du DOM
- Créer des directives d'attribut personnalisées pour étendre le comportement des éléments
- Implémenter les patterns de communication des directives en utilisant les host bindings et ElementRef
Sujets abordés
- âDirectives d'attribut vs directives structurelles
- âDirectives built-in (ngIf, ngFor, ngSwitch)
- âSĂ©lecteurs de directives et API
- âElementRef et manipulation du DOM
- âHost bindings et dĂ©corateurs listener
Activités
Créer des directives d'attribut personnalisées
Utiliser efficacement les directives built-in
Cours 2 : Jour 2 : Construire des Applications Interactives avec Formulaires & Routage
Objectifs
- Configurer et implémenter le routage dans les Single Page Applications
- Naviguer entre les routes en utilisant Ă la fois les approches template et programmatiques
- Passer et récupérer les données via les paramÚtres de route et les query strings
Sujets abordés
- âPhilosophie du routage dans les Single Page Applications
- âConfiguration et dĂ©finition des routes
- âRouter outlets et navigation
- âPatterns d'URL et paramĂštres
- âMĂ©thodes de navigation (routerLink, service Router)
Activités
Configurer un routage de base
Naviguer entre les routes
Passer des données à travers les paramÚtres de route
Objectifs
- Utiliser la syntaxe moderne de control flow Angular (@if, @for, @switch) pour la logique de rendu
- Rendre les listes dynamiques de maniĂšre efficace avec des performances optimales
- Migrer des directives structurelles héritées vers la syntaxe moderne de control flow
Sujets abordés
- âNouveau control flow Angular (@if, @for, @switch)
- âDirectives structurelles built-in (*ngIf, *ngFor, *ngSwitch)
- âPatterns de rendu conditionnel
- âRendu de listes et performances
- âMigration de l'ancienne Ă la nouvelle syntaxe
Activités
Rendre des listes dynamiques avec @for
GĂ©rer l'UI conditionnelle avec @if/@switch
Objectifs
- Récupérer les données des API REST en utilisant HttpClient et HTTP resources
- Gérer les réponses HTTP et les erreurs de maniÚre élégante dans les applications
- Relier les Observables et les Signals pour les patterns de chargement de données réactifs
Sujets abordés
- âConfiguration et utilisation de HttpClient
- âMĂ©thodes HTTP (GET, POST, PUT, DELETE)
- âHTTP resources pour le chargement rĂ©actif de donnĂ©es
- âTypes de rĂ©ponse et gestion d'erreurs
- âRelier les Observables et les Signals (toSignal, resource)
Activités
Récupérer des données d'une API REST
Afficher les données du serveur de maniÚre réactive
GĂ©rer les erreurs HTTP
Objectifs
- Construire des formulaires pilotés par template avec validation et affichage d'erreurs
- Implémenter la gestion de l'état du formulaire et la gestion de la soumission
- Utiliser les validateurs built-in pour assurer l'intégrité des données
Sujets abordés
- âFormsModule et directive ngModel
- âĂtat du formulaire et validation
- âRetour utilisateur et affichage d'erreurs
- âGestion de la soumission de formulaire
- âValidateurs built-in
Activités
Créer un formulaire de création de personne
Implémenter la validation de formulaire
Afficher les messages d'erreur de validation
Objectifs
- Construire des formulaires réactifs complexes en utilisant FormGroup et FormControl
- Implémenter des validateurs personnalisés pour les rÚgles de validation spécifiques au domaine
- Créer des composants de formulaire réutilisables avec les patterns réactifs
Sujets abordés
- âReactiveFormsModule et FormControl/FormGroup
- âConstruction de formulaires programmatique
- âPatterns de validation de formulaire
- âValidateurs personnalisĂ©s
- âFormulaires rĂ©actifs autonomes (sans NgModule)
Activités
Construire des formulaires avec FormGroup/FormControl
Implémenter une logique de validation complexe
Créer des composants de formulaire réutilisables
Objectifs
- Construire des formulaires modernes en utilisant l'API de formulaire basée sur les signals d'Angular
- Implémenter la gestion de formulaires type-safe avec les signals pour une meilleure expérience développeur
- Créer des contrÎles de formulaire personnalisés avec les patterns de composition basés sur les signals
Sujets abordés
- âAPI de formulaire basĂ©e sur les signals
- âDirective Field et composition de formulaires
- âGestion d'Ă©tat de formulaire avec les signals
- âValidation avec les signal forms
- âGestion de formulaires type-safe
Activités
Construire des formulaires avec l'API moderne de signal form
Implémenter des patterns de validation
Créer des contrÎles de formulaire personnalisés
Objectifs
- Ăvaluer et choisir l'approche de formulaire appropriĂ©e pour diffĂ©rents cas d'usage
- Migrer les formulaires existants entre les approches pilotées par template, réactives et basées sur les signals
- Optimiser les performances des formulaires en fonction des exigences du projet
Sujets abordés
- âFormulaires pilotĂ©s par template vs rĂ©actifs vs signal
- âQuand utiliser chaque approche
- âStratĂ©gies de migration
- âConsidĂ©rations de performance
Activités
Comparer les différentes approches de formulaires
Choisir la bonne stratégie de formulaire pour votre cas d'usage
Objectifs
- Combiner le routage avec le chargement de données réactif pour une navigation transparente
- Maßtriser les patterns de composition de signals pour les scénarios réactifs complexes
- Implémenter les workflows CRUD complets avec le flux de données réactif
Sujets abordés
- âCombiner le routage avec le chargement de donnĂ©es
- âPatterns de composition de signals
- âlinkedSignal pour les dĂ©pendances calculĂ©es
- âRxMethod et opĂ©rations asynchrones
- âWorkflows CRUD complets
Activités
Construire une page de détail/édition avec routage
Implémenter des opérations CRUD complÚtes
Maßtriser le flux de données réactif
Cours 3 : Jour 3 : Patterns Avancés & Architecture
Objectifs
- Implémenter le lazy loading et le code splitting pour une taille de bundle optimale
- Configurer les structures de routage imbriquées avec les routes enfants et les feature modules
- Optimiser les performances de l'application en utilisant les stratégies de preloading
Sujets abordés
- âLazy loading et code splitting
- âFeature modules et routage
- âRoutes enfants et routage imbriquĂ©
- âParamĂštres de route et query strings
- âStratĂ©gies de preloading de route
Activités
Implémenter des feature modules lazy-loaded
Configurer les routes enfants
Optimiser la taille du bundle avec le lazy loading
Objectifs
- Implémenter les guards de route pour protéger les routes en fonction de l'authentification et de l'autorisation
- Utiliser le chaßnage et la composition des guards pour les scénarios de contrÎle d'accÚs complexes
- Gérer la redirection de route et prévenir les changements non enregistrés avec les guards
Sujets abordés
- âTypes de guards (CanActivate, CanDeactivate, CanMatch)
- âSyntaxe de guard fonctionnel
- âGuards d'authentification et autorisation
- âPatterns de redirection de route
- âChaĂźnage et composition de guards
Activités
Implémenter des guards d'authentification
Protéger les routes en fonction des rÎles utilisateur
Gérer les changements non enregistrés
Objectifs
- Implémenter les resolvers pour pré-charger les données avant l'activation de la route
- Lier les données du resolver aux inputs des composants pour un flux de données transparent
- Gérer les défaillances de resolver de maniÚre élégante avec les patterns de gestion d'erreurs
Sujets abordés
- âPattern resolver et prĂ©-chargement de donnĂ©es
- âImplĂ©mentation de resolver
- âResolvers fonctionnels
- âBinding d'entrĂ©e de composant avec resolvers
- âGestion d'erreurs dans les resolvers
Activités
Implémenter des resolvers pour les données de route
Charger les données avant l'initialisation du composant
Gérer les défaillances de resolver gracieusement
Objectifs
- Implémenter les intercepteurs HTTP pour les préoccupations transversales (authentification, logging, gestion d'erreurs)
- Transformer les requĂȘtes et les rĂ©ponses globalement en utilisant les chaĂźnes d'intercepteurs
- Gérer les erreurs et implémenter la logique de retry au niveau de l'intercepteur
Sujets abordés
- âPattern intercepteur et cas d'usage
- âTransformation de requĂȘte/rĂ©ponse
- âGestion d'erreurs et logique de retry
- âInjection de token d'authentification
- âHTTP context pour un comportement conditionnel
Activités
Créer un intercepteur d'authentification
ImplĂ©menter la mise en cache de requĂȘte
GĂ©rer les erreurs HTTP globalement
Objectifs
- Utiliser la projection de contenu pour créer des composants flexibles et réutilisables
- Implémenter les slots nommés pour les projections de contenu multiples
- Construire les composants wrappers transparents avec les patterns de projection basés sur les signals
Sujets abordés
- âng-content pour la composition de composants
- âSlots nommĂ©s et projections multiples
- âComposants wrapper transparents
- âPatterns de projection basĂ©s sur les signals
- âĂtats de chargement et overlays
Activités
Créer un composant overlay réutilisable
Utiliser la projection de contenu pour la flexibilité
Construire des patterns d'Ă©tat de chargement
Objectifs
- Créer des composants génériques en utilisant ngTemplateOutlet pour le rendu dynamique de templates
- Utiliser ViewChild pour interroger et interagir avec les références de template
- Construire des composants hautement composables par la composition pilotée par template
Sujets abordés
- âng-template pour les templates rĂ©utilisables
- âng-container pour le regroupement logique
- ângTemplateOutlet pour les templates dynamiques
- âViewChild et rĂ©fĂ©rences de template
- âRequĂȘtes de contenu et gĂ©nĂ©riques
Activités
Créer des composants de liste générique
Implémenter la composition pilotée par template
Utiliser ViewChild pour l'interaction entre composants
Objectifs
- Créer des directives structurelles personnalisées pour la manipulation avancée du DOM
- Utiliser TemplateRef et ViewContainerRef pour l'instanciation impérative de composants
- MaĂźtriser les patterns de composition de directives pour la logique de template complexe
Sujets abordés
- âSyntaxe de directive structurelle (*directive)
- âTemplateRef et ViewContainerRef
- âCrĂ©er des directives structurelles personnalisĂ©es
- âCrĂ©ation impĂ©rative de composants
- âPatterns de composition de directives
Activités
Créer une directive structurelle personnalisée
Implémenter l'instanciation conditionnelle de composants
Maßtriser les patterns de templating avancés
Cours 4 : Jour 4 : Testing, Gestion d'Ătat & Sujets AvancĂ©s
Objectifs
- Ăcrire des tests unitaires complets pour les composants, services et directives Angular
- Atteindre 100% de couverture de code avec des stratégies de test efficaces
- Mocker les appels HTTP et les dépendances en utilisant les utilitaires de test Angular
Sujets abordés
- âOutils de test et configuration (Vitest, utilitaires de test Angular)
- âTest de composants avec TestBed
- âStratĂ©gies de test de composants
- âTest de services et appels HTTP
- âTest de directives et pipes
- âAngular Testing Library pour des tests rĂ©alistes
- âMocking et test doubles
- âCouverture de test et bonnes pratiques
Activités
Ăcrire des tests de composant complets
Tester les services avec HTTP mocké
Atteindre 100% de couverture de code
Objectifs
- Concevoir et implémenter la gestion d'état scalable en utilisant NgRx Signal Store
- Gérer les mutations d'état complexes, l'état dérivé et les opérations asynchrones
- Tester les applications basées sur le store avec l'isolation et le mocking appropriés
Sujets abordés
- âPatterns et principes de gestion d'Ă©tat
- âNgRx Signal Store vs NgRx classique
- âCrĂ©ation et provisionnement de stores
- âSĂ©lecteurs d'Ă©tat et valeurs calculĂ©es
- âwithComputed pour la dĂ©rivation d'Ă©tat
- âwithProps pour les actions paramĂ©trĂ©es
- âwithMethods et patchState pour les mutations
- âRxMethod pour les opĂ©rations asynchrones
- âStore hooks pour l'initialisation
- âProviders scoped par route
- âPatterns de gestion d'entitĂ©s
- âTest des composants basĂ©s sur le store
Activités
Construire un store complet pour le répertoire du personnel
Implémenter des mutations d'état complexes
GĂ©rer les effets secondaires asynchrones avec RxMethod
Tester les applications basées sur le store
Objectifs
- Optimiser les performances de l'application en utilisant la stratégie de change detection OnPush
- Construire des applications zoneless avec des performances améliorées et moins de surcharge JavaScript
- DĂ©boguer les problĂšmes de change detection et surveiller les implications de performance
Sujets abordés
- âMĂ©canisme de change detection
- âStratĂ©gie OnPush pour l'optimisation
- âApplications zoneless
- âImplications de performance
- âDebugging de change detection
Activités
Optimiser avec la stratégie OnPush
Construire des applications zoneless
Objectifs
- Transformer les applications Angular en Progressive Web Apps avec support offline
- Implémenter les Service Workers pour les stratégies de caching et les opérations en arriÚre-plan
- Activer les patterns offline-first pour une meilleure expérience utilisateur
Sujets abordés
- âFondamentaux et avantages des PWA
- âIntĂ©gration du package @angular/pwa
- âFondamentaux des Service Workers
- âCommunication avec les Service Workers
- âStratĂ©gies de caching
- âPatterns offline-first
Activités
Ajouter les capacités PWA à une application Angular
Implémenter la communication avec les service workers
Objectifs
- Configurer le Server-Side Rendering pour les performances améliorées et le SEO
- Implémenter les patterns de code compatibles avec le serveur et gérer correctement l'hydratation
- Optimiser les stratégies de rendu pour les différents scénarios de déploiement
Sujets abordés
- âAvantages et cas d'usage du SSR
- âModes de rendu (dĂ©veloppement, production, prĂ©rendering)
- âPatterns de code compatible avec le serveur
- âHTTP et hydratation
- âConsidĂ©rations de performance
- âOptimisation SEO
Activités
Configurer SSR pour une application Angular
Gérer la récupération de données cÎté serveur
Optimiser l'hydratation
Objectifs
- Créer et structurer des librairies Angular publiables pour la réutilisation du code
- Construire, empaqueter et distribuer les librairies Angular vers npm
- Gérer les dépendances et le versioning pour la maintenabilité de la librairie
Sujets abordés
- âCrĂ©er des librairies publiables
- âStructure de projet de librairie
- âConstruction et packaging avec ng-packagr
- âGestion des dĂ©pendances
- âGestion des assets dans les librairies
- âDocumentation et versioning
- âPublication sur npm
Activités
Créer une librairie de composants partagés
Construire et publier une librairie Angular
Objectifs
- Concevoir et implémenter des architectures micro-frontends en utilisant Native Federation
- Partager efficacement les dépendances entre les applications hÎte et distantes
- Activer la communication transparente entre les applications micro-frontends indépendantes
Sujets abordés
- âArchitecture micro-frontends
- âConcepts de Module Federation
- âApplications hĂŽte et distantes
- âPartage de dĂ©pendances
- âCommunication entre micro-frontends
- âNative Federation (spĂ©cifique Ă Angular)
Activités
Configurer une architecture micro-frontends
Partager des dépendances entre applications
Objectifs
- Optimiser les performances de l'application pour respecter les standards Core Web Vitals
- Implémenter le lazy loading et les deferred views pour des temps de chargement initiaux plus rapides
- Surveiller et analyser les métriques de performance pour l'amélioration continue
Sujets abordés
- âCore Web Vitals et mĂ©triques
- âStratĂ©gies d'optimisation d'images
- âLazy loading de composants au runtime
- âDeferred views pour le contenu below-the-fold
- âAnalyse et optimisation de bundle
- âMonitoring de performance
Activités
Optimiser les images pour le web
Implémenter des composants lazy-loaded
Différer les vues non critiques
Formations associées
Prochaines sessions
2 novembre 2026
Distanciel ⹠Français
Processus Qualité
L'engagement de SFEIR Institute : une démarche d'excellence pour garantir la qualité et la réussite de toutes nos formations. En savoir plus sur notre démarche qualité
Méthodes pédagogiques mobilisées
- Lectures / Apports thĂ©oriques (Slides) â PrĂ©sentation de concepts via des supports visuels (PowerPoint, PDF).
- DĂ©monstration technique (DĂ©mos) â Le formateur rĂ©alise une manipulation ou une procĂ©dure devant les apprenants.
- Laboratoires dirigĂ©s (Labs) â Mise en pratique guidĂ©e sur logiciel, machine ou environnement technique.
Dispositif d'Ă©valuation et de suivi
L'atteinte des objectifs de la formation est évaluée à plusieurs niveaux pour garantir la qualité de la prestation :
- Ăvaluation continue des acquis : VĂ©rification des connaissances tout au long de la formation via des mĂ©thodes participatives (en fonction de la formation: quiz, exercices pratiques, mises en situation) sous la supervision du formateur.
- Mesure de la progression : Dispositif d'auto-évaluation comparatif comprenant un diagnostic initial pour situer le niveau de départ, suivi d'une évaluation finale pour valider l'évolution des compétences.
- Ăvaluation de la qualitĂ© : Questionnaire de satisfaction en fin de session pour mesurer la pertinence et l'efficacitĂ© de la formation ressentie par les participants.
Former plusieurs collaborateurs
- Tarifs dégressifs (plusieurs places)
- Session privée ou sur-mesure
- En présentiel ou à distance