J'ai longtemps résisté à TypeScript. "Du JavaScript avec des types, pour quoi faire ?" Puis j'ai passé une nuit à debugger un undefined is not a function en production. Cette nuit-là, j'ai compris.

Le problème avec JavaScript pur

JavaScript est permissif. Trop permissif. Il vous laisse :

// Ça compile, ça tourne... puis ça plante à 3h du matin
function getUser(id) {
  return fetch(`/api/users/${id}`);
}

const user = getUser(123);
console.log(user.name); // undefined - fetch retourne une Promise !

Le bug est évident ici. Dans une codebase de 50 000 lignes, il l'est beaucoup moins.

Ce que TypeScript apporte concrètement

1. Les erreurs au build, pas en production

interface User {
  id: number;
  name: string;
  email: string;
}

async function getUser(id: number): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  return response.json();
}

const user = await getUser(123);
console.log(user.name); // TypeScript sait que c'est une string

L'erreur de tout à l'heure ? TypeScript l'aurait attrapée immédiatement.

2. L'autocomplétion qui fait gagner du temps

Fini de consulter la documentation toutes les 5 minutes. Votre IDE sait exactement quelles propriétés sont disponibles, quels paramètres une fonction attend.

3. Le refactoring sans stress

Renommer une propriété utilisée dans 47 fichiers ? TypeScript vous montre instantanément tous les endroits à modifier. Pas de regex hasardeuse, pas de "j'espère que j'ai tout trouvé".

Les objections courantes (et mes réponses)

"Ça ralentit le développement"

Au début, oui. Après quelques semaines, vous codez plus vite parce que vous passez moins de temps à debugger.

"C'est trop verbeux"

TypeScript a beaucoup évolué. L'inférence de types fait 80% du travail :

// Pas besoin d'annoter, TypeScript comprend
const numbers = [1, 2, 3]; // number[]
const doubled = numbers.map(n => n * 2); // number[]

"Mon projet est trop petit"

C'est justement le meilleur moment pour commencer. Migrer une grosse codebase est douloureux. Démarrer en TypeScript dès le jour 1 est gratuit.

Comment adopter TypeScript progressivement

Pas besoin de tout réécrire. Voici une approche progressive :

1. Configurer tsconfig.json en mode permissif — strict: false au début
2. Renommer les fichiers .js en .ts — un par un
3. Ajouter les types aux nouvelles fonctions — ne pas toucher au code existant
4. Activer les règles strict progressivement — une par une

En 3 mois, vous aurez une codebase typée sans avoir bloqué la production.

Mon setup TypeScript recommandé

{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitReturns": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}

Ces options attrapent 90% des bugs courants sans être trop contraignantes.

Le verdict

TypeScript n'est pas parfait. La courbe d'apprentissage existe. Certains types complexes peuvent devenir illisibles.

Mais pour tout projet qui dépasse le prototype jetable, c'est un investissement rentable. Moins de bugs, plus de confiance, une meilleure documentation vivante du code.

Si vous hésitez encore, essayez sur un petit projet personnel. Vous ne reviendrez pas en arrière.