0Pricing
TypeScript Academy · Leçon

Vérification des types en intégration continue : stratégies et outils

Exécutez efficacement les vérifications de types dans les pipelines d’intégration continue

Vérification des types en intégration continue : stratégies et outils est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Pourquoi vérifier les types dans l’intégration continue ?

Effectuer la vérification des types TypeScript dans l’intégration continue permet de détecter les erreurs de types que les développeurs ne repèrent pas localement, en particulier dans les grandes équipes où les modifications d’un paquet peuvent en interrompre un autre.

# Simple CI type check step
npx tsc --noEmit

Indicateur --noEmit

tsc --noEmit exécute le vérificateur de types complet, mais ignore la sortie JavaScript : c’est idéal pour vérifier les types dans l’intégration continue sans générer de fichiers.

# GitHub Actions step
- name: Type Check
  run: npx tsc --noEmit

Vérification incrémentielle des types dans l’intégration continue

Utilisez --incremental avec la mise en cache de l’intégration continue pour restaurer le fichier .tsbuildinfo et ne vérifier à nouveau que les fichiers modifiés.

# Cache .tsbuildinfo in CI (GitHub Actions)
- uses: actions/cache@v3
  with:
    path: .tsbuildinfo
    key: tsc-${{ hashFiles('src/**/*.ts') }}

Références de projets dans l’intégration continue

Dans un monodépôt, tsc --build --noEmit vérifie les types de tous les paquets en respectant les dépendances entre références de projets.

# Type-check all project references
npx tsc --build --noEmit

Vérification des types uniquement pour les éléments concernés avec Nx

Nx peut détecter quels paquets sont concernés par une PR et vérifier uniquement ceux-ci, en ignorant les paquets inchangés.

# Only type-check affected projects
npx nx affected --target=typecheck --base=origin/main

Vérification des types avec Turborepo

Ajoutez un script typecheck à chaque paquet, puis exécutez-le avec Turborepo en utilisant la mise en cache et la parallélisation.

// package.json
{ "scripts": { "typecheck": "tsc --noEmit" } }

// turbo.json pipeline
{ "typecheck": { "dependsOn": ["^typecheck"], "outputs": [] } }

// Run:
npx turbo typecheck

Paralléliser les vérifications de types

Pour les paquets indépendants, exécutez les vérifications de types en parallèle avec des outils comme concurrently ou npm-run-all.

npx concurrently \
  "tsc -p packages/core/tsconfig.json --noEmit" \
  "tsc -p packages/ui/tsconfig.json --noEmit"

Faire échouer l’intégration continue en cas d’erreurs de types

Assurez-vous que l’intégration continue échoue à la moindre erreur TypeScript en vérifiant le code de sortie. tsc --noEmit se termine avec le code 1 lorsqu’il y a des erreurs.

# CI step — fails if tsc exits 1
- name: Type Check
  run: npx tsc --noEmit
  # No continue-on-error: true here

Vérifier les types uniquement pour les PR

Utilisez GitHub Actions pour vérifier les types uniquement des fichiers modifiés dans une PR afin de réduire la durée de l’intégration continue pour les grands dépôts.

# Use ts-affected or custom script to detect changed TS files
# Then run tsc only for affected tsconfig projects

Signaler les erreurs de types dans les commentaires de PR

Des outils comme danger-js peuvent analyser la sortie de tsc et publier les erreurs de types sous forme de commentaires intégrés dans la revue d’une PR, pour une meilleure visibilité.

// dangerfile.ts
import { danger, fail } from "danger";
// Parse tsc --noEmit output and report errors inline

Récapitulatif : vérification des types dans l’intégration continue

Exécutez tsc --noEmit dans l’intégration continue pour garantir l’exactitude. Utilisez --incremental et la mise en cache pour gagner en rapidité. Dans les monodépôts, utilisez tsc --build, Turborepo ou l’analyse des éléments concernés de Nx afin de réduire le travail pour chaque PR.

Vérification rapide

Quel indicateur de tsc vérifie les types sans générer de fichiers de sortie ?

Ce que vous avez appris

La vérification des types dans l’intégration continue utilise tsc --noEmit pour contrôler l’exactitude sans générer de fichiers. Combinez-la avec --incremental, les références de projets et des outils de mise en cache comme Turborepo et Nx pour obtenir une vérification des types rapide et évolutive dans les grands monodépôts.

Questions Fréquemment Posées

La leçon « Vérification des types en intégration continue : stratégies et outils » est-elle gratuite ?

Oui — le texte complet de « Vérification des types en intégration continue : stratégies et outils » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Vérification des types en intégration continue : stratégies et outils » ?

Exécutez efficacement les vérifications de types dans les pipelines d’intégration continue Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Vérification des types en intégration continue : stratégies et outils » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Profiler une compilation TypeScript lente
  2. Éviter les opérations de types coûteuses
  3. skipLibCheck et déclarations isolées
  4. Vérification des types en intégration continue : stratégies et outils
← Retour à TypeScript Academy