TypeScript — Bien comprendre les types (bases → objets → optionnels)

1) Types de base (string, number, boolean)

En TypeScript, on peut laisser TS deviner (inférence) ou annoter nous-mêmes.


    // TypeScript DEVINE le type: myName est un string
    let myName = "Bob";

    // ⛔ Erreur: 5 n'est pas un string
    // (TypeScript te le dit AU MOMENT où tu écris)
    // myName = 5;

2) Types personnalisés (alias)

Un alias de type donne un nom à un type. Par convention, on met une majuscule.


  // Alias de type simple
  type Food = string;
  let favoriteFood: Food = "pizza";

  // Alias d'objet
  type Person = {
    name: string;
    age: number;
    isStudent: boolean;
  };

  const p1: Person = { name: "Joe", age: 42, isStudent: true };
  const p2: Person = { name: "Jill", age: 66, isStudent: false };

  // Remarque: dans un 'type' objet, tu peux séparer par ; ou , ou juste des retours à la ligne.

type vs interface (tu peux ignorer au début)

type est très flexible (unions, fonctions, primitif). interface s'étend bien pour des objets publics.

Les deux sont compatibles structurellement. Le plus important: être cohérent dans le projet.

3) Objets imbriqués (nested)

Tu peux déclarer l’objet imbriqué à l’intérieur… ou créer un type séparé pour le réutiliser (plus propre).


    type Person = {
      name: string;
      age: number;
      isStudent: boolean;
      address: {
        street: string;
        city: string;
        country: string;
      };
    };

    const bob: Person = {
      name: "Bob",
      age: 30,
      isStudent: false,
      address: { street: "1 rue Bleue", city: "Paris", country: "FR" }
    };

4) Propriétés optionnelles (le point d’interrogation)

Le ? dit à TS: “Cette propriété peut manquer (ou être undefined).”


  type Address = {
    street: string;
    city: string;
    country: string;
  };

  type Person = {
    name: string;
    age: number;
    isStudent: boolean;
    address?: Address; // <-- optionnelle
  };

  const sam: Person = { name: "Sam", age: 18, isStudent: true };
  // sam.address peut être absent → il faut vérifier

Deux façons sûres d’accéder à une propriété potentiellement absente :


    // ?. arrête la chaîne si c'est undefined
    const city = sam.address?.city;
    // city: string | undefined

Bonus (facultatif) — Unions très simples

Parfois une valeur peut être de plusieurs formes. On le dit clairement avec une union.


  type Id = number | string;

  function toText(id: Id): string {
    // TS "rétrécit" (narrow) selon le test
    if (typeof id === "number") {
      return id.toFixed(0);
    }
    return id.trim();
  }

Pourquoi c'est utile ?

Sans union, tu aurais mis any et perdu l'aide de TS. Avec l'union, TS t'oblige à traiter les deux cas de façon sûre.

Récap express

Bases : string, number, boolean. Laisse l’inférence te simplifier la vie.
Types personnalisés : un type donne un nom clair à une forme de donnée.
Objets imbriqués : sépare les sous-objets en types dédiés (ex: Address).
Optionnels : utiles, mais attention aux accès (utilise ?. et ??).
Unions (bonus) : décrivent plusieurs formes possibles sans tomber dans any.