TypeScript Academy · Leçon

Littéraux booléens et inférence des littéraux

Comprendre comment TypeScript élargit ou restreint l’inférence des littéraux.

Leçon 2 sur 413 étapes

Littéraux booléens et inférence des littéraux est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Types littéraux booléens

Le type boolean est en réalité l’union true | false. Chacun de ces éléments est un type littéral booléen : un type qui n’autorise qu’une seule valeur booléenne précise.

let yes: true = true;
let no: false = false;
console.log(yes, no);
// yes = false; // Error: false not assignable to true

Littéraux booléens dans les unions

Les littéraux booléens sont particulièrement utiles lorsqu’ils sont associés à d’autres littéraux pour modéliser des résultats discriminés, par exemple un indicateur de réussite associé à la forme des données renvoyées.

type Result =
  | { ok: true; value: number }
  | { ok: false; error: string };

const r: Result = { ok: true, value: 42 };
console.log(r);

Élargissement des types

Lorsque vous initialisez une variable, TypeScript détermine le type à inférer. Il conserve parfois le littéral précis et élargit parfois le type général. Comprendre ce mécanisme est essentiel pour obtenir des types prévisibles.

const exact = 'hello'; // type: 'hello' (literal)
let broad = 'hello';   // type: string (widened)
console.log(exact, broad);

Avec let, le type s’élargit vers le type général

Comme une variable let peut être réaffectée, TypeScript infère le type général afin d’autoriser les affectations futures. Une chaîne déclarée avec let commence avec le type string, et non avec le littéral.

let mood = 'happy'; // inferred as string
mood = 'sad';       // allowed
mood = 'tired';     // allowed
console.log(mood);

const conserve le littéral

Une constante const ne peut jamais être réaffectée, alors TypeScript infère le type le plus précis : le littéral. C’est pourquoi const greeting = 'hi' a le type 'hi', et non string.

const greeting = 'hi'; // type: 'hi'

type Greeting = typeof greeting; // 'hi'
const other: Greeting = 'hi';
console.log(other);

Élargissement avec les nombres et les booléens

La même règle s’applique aux nombres et aux booléens. const conserve 42 ou true comme littéral, tandis que let élargit le type en number ou boolean.

const n = 42;   // type: 42
const b = true; // type: true
let m = 42;     // type: number
let c = true;   // type: boolean
console.log(n, b, m, c);

Pourquoi l’élargissement existe

L’élargissement rend le code courant plus pratique. Si chaque let count = 0 était typé comme le littéral 0, vous ne pourriez pas l’incrémenter. L’élargissement permet aux variables réaffectables de se comporter naturellement.

let count = 0; // widened to number
count = count + 1;
count = 10;
console.log('Count:', count);

Forcer un littéral avec une annotation

Vous pouvez parfois vouloir qu’une variable let reste un littéral. Ajoutez une annotation explicite de type littéral : TypeScript le conservera alors de manière précise tout en vous permettant de le réaffecter au sein de cette union.

let status: 'on' | 'off' = 'on';
status = 'off'; // allowed
console.log(status);
// status = 'paused'; // Error

Élargissement dans les propriétés d’objet

Les propriétés des littéraux d’objet s’élargissent également par défaut. Même dans un objet const, les propriétés modifiables reçoivent le type général, car la propriété elle-même peut être réaffectée.

const config = { mode: 'dark' };
// config.mode has type string, not 'dark'
config.mode = 'light';
console.log(config.mode);

Inférence des littéraux avec les fonctions

Les valeurs renvoyées par les fonctions sont également inférées. Une fonction qui renvoie une valeur littérale const élargit tout de même son type de retour au type général, sauf si vous l’annotez ou utilisez des types littéraux dans sa signature.

function getMode(): 'dark' | 'light' {
  return 'dark';
}

const m = getMode(); // type: 'dark' | 'light'
console.log(m);

Choisir entre le littéral et le type général

Règle générale : utilisez const ou des annotations littérales explicites lorsque vous avez besoin de valeurs exactes (clés de configuration, discriminants). Laissez l'élargissement se produire pour les variables ordinaires et modifiables. Savoir lequel vous obtiendrez évite les erreurs d'affectation inattendues.

const KEY = 'apiUrl';     // literal 'apiUrl'
let retries = 3;          // number
let level: 'low' | 'high' = 'low'; // pinned literal
console.log(KEY, retries, level);

Vérification rapide

Évaluez votre compréhension de l'élargissement et de l'inférence des littéraux.

Réponds-y dans la leçon interactive

Récapitulatif : inférence des littéraux

Points essentiels :

true et false sont des types littéraux ; boolean équivaut à true | false.
let s'élargit vers le type général (string, number, boolean).
const conserve le type littéral exact.
Annotez avec un type littéral pour fixer un let à une union étroite.

Ensuite, nous rendrons l'immuabilité explicite avec as const.

const literal = 'fixed'; // 'fixed'
let widened = 'fixed';   // string
let pinned: 'a' | 'b' = 'a';
console.log(literal, widened, pinned);

Gratuit pour commencer

Apprends TypeScript avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 101
Leçons: 352

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Littéraux booléens et inférence des littéraux » est-elle gratuite ?

Oui — le texte complet de « Littéraux booléens et inférence des littéraux » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Littéraux booléens et inférence des littéraux » ?

Comprendre comment TypeScript élargit ou restreint l’inférence des littéraux. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Littéraux booléens et inférence des littéraux » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Types littéraux de chaînes et de nombres
Littéraux booléens et inférence des littéraux
Assertions const avec as const
Combiner des littéraux en unions

← Retour à TypeScript Academy