🔷 Pourquoi TypeScript ?

TypeScript est un sur-ensemble typé de JavaScript développé par Microsoft. Il compile vers du JavaScript standard et ajoute une couche de vérification statique des types à la compilation.

// JavaScript — pas d'erreur avant l'exécution
function add(a, b) { return a + b; }
add("5", 3); // "53" — bug silencieux !

// TypeScript — erreur à la compilation
function add(a: number, b: number): number { return a + b; }
add("5", 3); // ❌ Erreur TS2345: Argument of type 'string' is not assignable to 'number'

📦 Types primitifs

🔢 Types complexes — Array & Tuple

// Tableaux — deux syntaxes équivalentes
const names: string[] = ["Alice", "Bob"];
const scores: Array<number> = [10, 20, 30];

// Tuple — longueur et types fixes
const point: [number, number] = [48.8, 2.3];
const entry: [string, number, boolean] = ["Alice", 30, true];

// Tableau readonly
const ids: readonly number[] = [1, 2, 3];
ids.push(4); // ❌ Erreur — tableau en lecture seule

⚠️ any, unknown, never, void

// any — désactive la vérification (à éviter)
let data: any = "hello";
data = 42;       // OK — tout est permis
data.foo();     // OK à la compilation, crash possible à l'exécution

// unknown — plus sûr que any
let input: unknown = getUserInput();
if (typeof input === "string") {
  console.log(input.toUpperCase()); // OK après narrowing
}

// void — fonction sans valeur de retour
function logMessage(msg: string): void {
  console.log(msg);
  // pas de return (ou return sans valeur)
}

// never — code inaccessible / throw toujours
function throwError(msg: string): never {
  throw new Error(msg); // ne retourne jamais
}

🎯 Inférence de type

TypeScript infère le type automatiquement à partir de la valeur assignée. Pas besoin d'annoter partout.

// L'inférence déduit le type
let name = "Alice";     // inféré : string
let age  = 30;          // inféré : number
let ok   = true;        // inféré : boolean
let nums = [1, 2, 3];  // inféré : number[]

// Annotez explicitement quand l'inférence est ambiguë
let result: string | null = null; // inféré : null sans annotation

// Const — type littéral inféré
const status = "active"; // type : "active" (pas string)
let   role   = "admin";  // type : string (let est mutable)

🔍 Type assertions

// as — assertion de type (vous connaissez mieux que TS)
const input = document.getElementById("name") as HTMLInputElement;
console.log(input.value); // TS sait que c'est un HTMLInputElement

// Non-null assertion operator !
const btn = document.querySelector(".btn")!; // garanti non-null

// satisfies (TS 4.9+) — valide le type sans le caster
const config = {
  env: "production",
  port: 3000
} satisfies { env: string; port: number };
// config.env garde le type littéral "production" !

⚡ Compiler TypeScript

# Installer TypeScript
npm install -g typescript
npm install --save-dev typescript

# Compiler un fichier
tsc app.ts

# Initialiser tsconfig.json
tsc --init

# Compiler en mode watch
tsc --watch

# Exécuter directement (dev)
npx ts-node app.ts
npx tsx app.ts       # plus rapide, ESM