TypeScript Academy · Leçon

Types littéraux de chaînes et de nombres

Limiter les valeurs à des chaînes et des nombres exacts grâce aux types littéraux.

Types littéraux de chaînes et de nombres est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu’est-ce qu’un type littéral ?

La plupart des types décrivent un ensemble de valeurs. string désigne n’importe quelle chaîne, et number n’importe quel nombre. Un type littéral réduit cet ensemble à une seule valeur précise.

Le type 'north' n’autorise que la chaîne 'north' : rien d’autre. Les types littéraux vous permettent de modéliser des ensembles finis et précis de valeurs autorisées directement dans le système de types.

let dir: 'north' = 'north';
console.log(dir);
// dir = 'south'; // Error: not assignable to type 'north'

Unions de littéraux de chaîne

Un littéral seul n’est pas très utile. Combinez-en plusieurs avec | pour former une union de littéraux. C’est la manière idiomatique de modéliser un ensemble fixe d’options.

Direction ne peut être que l’une de quatre chaînes précises.

type Direction = 'north' | 'south' | 'east' | 'west';

let heading: Direction = 'east';
console.log('Heading:', heading);

heading = 'west';
console.log('Now:', heading);

Rejeter les valeurs invalides

La puissance des unions de littéraux vient du fait que le compilateur rejette toute valeur qui ne fait pas partie de l’ensemble autorisé. Les fautes de frappe et les options invalides deviennent des erreurs de compilation plutôt que des bogues à l’exécution.

type Direction = 'north' | 'south' | 'east' | 'west';

let heading: Direction = 'north';
console.log(heading);
// heading = 'up'; // Error: '"up"' is not assignable to 'Direction'

Littéraux comme paramètres de fonction

Utilisez les unions de littéraux pour les paramètres de fonction qui n’acceptent que certaines valeurs. L’appelant bénéficie de la complétion automatique et ne peut pas transmettre une valeur invalide.

type Direction = 'north' | 'south' | 'east' | 'west';

function move(dir: Direction): string {
  return 'Moving ' + dir;
}

console.log(move('south'));
// console.log(move('left')); // Error

Types littéraux numériques

Les types littéraux ne concernent pas uniquement les chaînes. Vous pouvez également utiliser des nombres précis. Un exemple classique est un dé à six faces, dont la valeur doit être comprise entre 1 et 6.

type Dice = 1 | 2 | 3 | 4 | 5 | 6;

function roll(): Dice {
  return (Math.floor(Math.random() * 6) + 1) as Dice;
}

console.log('Rolled:', roll());

Littéraux numériques dans les paramètres

Les unions de littéraux numériques limitent les entrées à un ensemble précis de nombres, ce qui convient parfaitement aux niveaux de qualité, aux codes de type HTTP ou aux dimensions de grille.

type Quality = 1 | 2 | 3;

function setQuality(level: Quality): void {
  console.log('Quality set to', level);
}

setQuality(2);
// setQuality(5); // Error: 5 is not 1 | 2 | 3

Mélanger des littéraux de chaîne et des littéraux numériques

Une union peut combiner plusieurs catégories de littéraux. C’est pratique pour les API qui acceptent soit un préréglage nommé, soit une valeur brute.

type Size = 'small' | 'large' | 0 | 100;

function resize(s: Size): void {
  console.log('Resizing to', s);
}

resize('small');
resize(100);

Types littéraux booléens

Même les booléens ont des types littéraux : true et false sont à la fois des types et des valeurs. Le type boolean complet n’est en réalité que true | false.

type AlwaysOn = true;

let enabled: AlwaysOn = true;
console.log('Enabled:', enabled);
// enabled = false; // Error: false not assignable to true

Les littéraux améliorent la documentation

Une union de littéraux sert également de documentation. Toute personne qui lit type Status = 'idle' | 'loading' | 'done' connaît immédiatement tous les états possibles : aucune supposition, aucune chaîne magique dispersée dans le code.

type Status = 'idle' | 'loading' | 'done';

function render(s: Status): string {
  return 'State is: ' + s;
}

console.log(render('loading'));

Combiner des littéraux avec d’autres types

Vous pouvez mélanger des types littéraux avec des types plus généraux dans une union. Un schéma courant est 'auto' | number, qui signifie soit le mot-clé spécial 'auto', soit n’importe quel nombre.

type Width = 'auto' | number;

function setWidth(w: Width): void {
  console.log('Width:', w);
}

setWidth('auto');
setWidth(320);

Littéraux comme constantes nommées

Les types littéraux s’associent très bien aux constantes nommées. Définissez le type une seule fois, réutilisez-le partout et refactorisez sans risque. Le compilateur garantit la cohérence de chaque utilisation.

type Theme = 'light' | 'dark';

const DEFAULT_THEME: Theme = 'dark';

function applyTheme(t: Theme): void {
  console.log('Applying', t, 'theme');
}

applyTheme(DEFAULT_THEME);

Vérification rapide

Testez vos connaissances sur les types littéraux.

Récapitulatif : types littéraux

Vous avez appris que :

Les types littéraux représentent une seule valeur précise, par exemple 'north' ou 6.
Combiner des littéraux avec | crée une union finie de valeurs autorisées.
Ils fonctionnent avec les chaînes, les nombres et les booléens, et peuvent être combinés avec des types plus généraux comme 'auto' | number.
Utilisés comme paramètres de fonction, ils offrent la complétion automatique et rejettent les entrées invalides au moment de la compilation.

Ensuite, vous verrez comment TypeScript choisit entre les types littéraux et les types élargis.

type Direction = 'north' | 'south' | 'east' | 'west';
type Dice = 1 | 2 | 3 | 4 | 5 | 6;

function describe(d: Direction, n: Dice): string {
  return 'Go ' + d + ' ' + n + ' steps';
}

console.log(describe('north', 3));

Questions Fréquemment Posées

La leçon « Types littéraux de chaînes et de nombres » est-elle gratuite ?

Oui — le texte complet de « Types littéraux de chaînes et de nombres » 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 « Types littéraux de chaînes et de nombres » ?

Limiter les valeurs à des chaînes et des nombres exacts grâce aux types 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 1 sur 4.

Combien de temps prend la leçon « Types littéraux de chaînes et de nombres » ?

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