Types primitifs et inférence

TypeScript décrit la forme des données. Les types primitifs couvrent les valeurs simples que tout programme manipule.

🔤 Types primitifs

Un primitif est un type de valeur élémentaire, indivisible. Ce n'est ni un objet ni un tableau — juste une valeur brute (texte, nombre, booléen…).

let nom: string = "Alice"
let age: number = 25
let actif: boolean = true
let rien: null = null

🧠 Inférence

L'inférence est la capacité de TypeScript à déduire automatiquement le type d'une variable à partir de sa valeur initiale, sans qu'on ait besoin de l'écrire explicitement.

TypeScript déduit le type à partir de la valeur :

const langage = "TypeScript"   // déduit : "TypeScript" (littéral)
let compteur = 0               // déduit : number (élargi)
// compteur = "x"              // ❌ erreur : Type 'string' is not assignable to type 'number'

Un type littéral est un type aussi précis que la valeur elle-même. const x = "Alice" a pour type "Alice" (pas string). C'est la forme la plus précise.

const fige le type littéral, let l'élargit :

const prenom = "Alice"   // type : "Alice" (littéral)
let nom = "Alice"         // type : string (élargi)

Le type élargi arrive quand TypeScript généralise un type. let x = "Alice" élargit à string (toutes les chaînes possibles), pas juste "Alice".

📦 Tableaux et objets

const notes: number[] = [12, 18, 15]
const utilisateur: { nom: string; age: number } = { nom: "Alice", age: 25 }
// notes.push("x")           // ❌ erreur
// utilisateur.age = "vingt" // ❌ erreur

⚠️ unknown vs any

any désactive toute vérification. Utile en dernier recours, mais dangereux — une variable any accepte tout (lecture, écriture, appel de méthode) sans erreur.

unknown représente une valeur dont on ne connaît pas le type. Contrairement à any, il faut prouver sa forme (via un narrowing) avant de pouvoir l'utiliser. C'est la version sûre.

let u: unknown = 42
// u.toString()              // ❌ erreur
if (typeof u === "number") {
  u.toString()              // ✅ OK
}

📋 Points clés

• Sept primitives : string, number, boolean, null, undefined, bigint, symbol.
• Inférence : TypeScript déduit le type à partir de la valeur.
• const produit un type littéral (précis) ; let produit un type élargi (général).
• Préférez unknown (sûr, preuve obligatoire) à any (dangereux, tout accepté).

🔒 Immutabilité : readonly et as const

readonly est un modificateur qui empêche la réaffectation d'une propriété. Un tableau readonly number[] ne peut pas être modifié (push, pop…). C'est l'équivalent TypeScript de const pour les propriétés d'objet.

interface Config {
  readonly port: number
  readonly host: string
}

const config: Config = { port: 3000, host: "localhost" }
config.port = 8080   // ❌ erreur : readonly
Cannot assign to 'port' because it is a read-only property.

const notes: readonly number[] = [12, 18, 15]
notes.push(20)      // ❌ erreur : readonly array
Property 'push' does not exist on type 'readonly number[]'.

const config = {
  protocole: "https",
  port: 443,
  actif: true,
} as const

// config est : { readonly protocole: "https"; readonly port: 443; readonly actif: true }

⚙️ Configuration du compilateur : tsconfig.json

Pour utiliser TypeScript dans un projet, il faut un fichier tsconfig.json à la racine. Il configure le compilateur : cible (target), système de modules (module), dossiers source (rootDir) et sortie (outDir). C'est la centrale de configuration de tout projet TypeScript.

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "CommonJS",
    "strict": true,
    "outDir": "./dist",
    "rootDir": "./src"
  }
}

Sans ce fichier, tsc utilise ses options par défaut (souvent trop permissives). En production, on active toujours strict: true pour maximiser la sécurité.

✅ Vérification des acquis