Premiers pas : types de base et inférence

Premiers pas avec TypeScript

TypeScript est un sur-ensemble typé de JavaScript : tout code JavaScript valide est (presque toujours) du TypeScript valide, auquel on ajoute des annotations de types. Le compilateur vérifie ces types avant l’exécution, puis les efface : le navigateur ou Node.js n’exécute que du JavaScript.

function prixTTC(ht: number, taux: number): number {
  return ht * (1 + taux);
}

prixTTC(100, 0.2);     // 120
prixTTC("100", 0.2);   // Erreur de compilation : string n'est pas assignable à number

En JavaScript, la seconde ligne produirait silencieusement "1000.2"… ou un NaN plus loin. TypeScript transforme ce bug en erreur visible dans l’éditeur.

Installer et compiler

npm install --save-dev typescript   # TypeScript 7
npx tsc --init      # crée tsconfig.json (strict, module nodenext, target esnext)
npx tsc             # vérifie et compile les fichiers .ts en .js
npx tsc --noEmit    # vérifie seulement, sans produire de fichiers

TypeScript 7 est le compilateur réécrit en Go : mêmes règles de typage et même commande tsc, mais une vérification bien plus rapide. Gardez "strict": true dans tsconfig.json (c’est aussi le défaut depuis TypeScript 6). Le mode strict active notamment noImplicitAny (un paramètre sans type est une erreur) et strictNullChecks (null et undefined ne sont pas assignables à n’importe quel type).

Dans une configuration ancienne, tsc refuse désormais les options supprimées ("target": "ES5", "moduleResolution": "node", baseUrl, outFile) : retirez-les. Les types de Node.js ne sont plus chargés automatiquement : installez @types/node et ajoutez "types": ["node"].

Vite et Node.js 26 (node app.ts) exécutent du TypeScript en retirant les types, sans les vérifier ; Node refuse en plus les syntaxes qui produisent du code, comme enum. tsc --noEmit reste l’outil de vérification.

Les types de base

let nom: string = "Ada";
let age: number = 36;          // entiers et décimaux : un seul type number
let actif: boolean = true;
let notes: number[] = [12, 15.5];
let point: [number, number] = [48.85, 2.35]; // tuple : longueur et types fixés
let rien: null = null;
let pasEncore: undefined = undefined;

L’inférence : n’annotez pas tout

TypeScript déduit le type d’une variable initialisée :

let ville = "Lyon";   // inféré : string
ville = 69;           // Erreur : number n'est pas assignable à string
const tva = 0.2;      // inféré : le type littéral 0.2 (une constante ne change pas)
const totaux = [10, 20].map((n) => n * 2); // inféré : number[]

Règle pratique : annotez les paramètres de fonctions et les valeurs exportées ; laissez l’inférence travailler pour les variables locales.

any et unknown

any désactive toute vérification : à éviter, c’est une porte de sortie. unknown signifie « je ne sais pas encore » et oblige à vérifier avant d’utiliser :

function longueur(x: unknown): number {
  if (typeof x === "string") return x.length; // ici x est un string
  return 0;
}

null et undefined en mode strict

function initiale(nom: string | undefined): string {
  // nom.charAt(0) serait refusé : nom peut être undefined
  return nom ? nom.charAt(0) : "?";
}

Le type string | undefined est une union (vue en détail plus loin). Le compilateur vous force à traiter le cas manquant, ce qui élimine une grande partie des erreurs « Cannot read properties of undefined ».

À retenir

• Types vérifiés à la compilation, effacés à l’exécution.
• Annotez les entrées des fonctions, laissez l’inférence faire le reste.
• Préférez unknown à any, et gardez le mode strict.