TypeScript Academy · Leçon

Assertions const avec as const

Figer les objets et les tableaux en types littéraux profondément en lecture seule.

Assertions const avec as const est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

L'assertion as const

Une assertion const, écrite as const, indique à TypeScript d'inférer le type le plus spécifique, profondément readonly, pour une valeur. Les propriétés des objets deviennent littérales et immuables ; les tableaux deviennent des tuples en lecture seule.

const point = { x: 10, y: 20 } as const;
// type: { readonly x: 10; readonly y: 20 }
console.log(point.x, point.y);

Sans as const

Sans cette assertion, les propriétés des objets s'élargissent. { x: 10 } infère x: number, et la propriété est modifiable. Comparez cela à la scène précédente pour voir ce que change as const.

const a = { x: 10 };       // x: number, mutable
const b = { x: 10 } as const; // x: 10, readonly
a.x = 99; // allowed
console.log(a.x, b.x);

Figer les propriétés en littéraux

as const transforme chaque propriété de type chaîne en type littéral. C'est particulièrement utile pour les objets de configuration dont les clés et les valeurs doivent rester exactes.

const config = {
  env: 'production',
  retries: 3
} as const;
// env: 'production', retries: 3
console.log(config.env, config.retries);

readonly empêche les modifications

Comme as const rend les propriétés readonly, le compilateur bloque toute réaffectation. La valeur est immuable au niveau du type, ce qui la protège contre les changements accidentels.

const settings = { mode: 'dark' } as const;
console.log(settings.mode);
// settings.mode = 'light'; // Error: readonly property

Assertions const sur les tableaux

Appliqué à un tableau, as const produit un tuple en lecture seule de types littéraux. La longueur est fixe et chaque élément conserve sa valeur exacte.

const colors = ['red', 'green', 'blue'] as const;
// type: readonly ['red', 'green', 'blue']
console.log(colors[0], colors.length);

Aucune modification des tableaux en lecture seule

Un tuple en lecture seule refuse les méthodes de modification comme push ou l'affectation d'un index. Les données sont verrouillées, ce qui est exactement ce qu'il vous faut pour des tables de correspondance fixes.

const days = ['Mon', 'Tue', 'Wed'] as const;
console.log(days.join(', '));
// days.push('Thu'); // Error: push does not exist on readonly tuple

Dériver une union avec typeof arr[number]

Voici un modèle puissant : prenez un tableau readonly et dérivez une union de ses types d'éléments à l'aide de typeof arr[number]. Vous écrivez les valeurs une seule fois et obtenez gratuitement une union littérale.

const ROLES = ['admin', 'editor', 'viewer'] as const;
type Role = typeof ROLES[number];
// 'admin' | 'editor' | 'viewer'
const r: Role = 'editor';
console.log(r);

Source unique de vérité

Ainsi, votre tableau d'exécution et votre type restent synchronisés. Ajoutez une valeur au tableau, et l'union est automatiquement mise à jour — aucune liste dupliquée à maintenir.

const SIZES = ['S', 'M', 'L', 'XL'] as const;
type Size = typeof SIZES[number];

function pick(s: Size): void {
  console.log('Picked', s);
}
pick('M');

Assertions const sur les tuples

Pour les tuples dont les types d'éléments diffèrent, as const préserve à la fois les types exacts et l'ordre, ce qui produit un tuple précis en lecture seule.

const pair = [1, 'one'] as const;
// type: readonly [1, 'one']
console.log(pair[0], pair[1]);

Comportement de lecture seule en profondeur

as const s'applique en profondeur. Les objets et tableaux imbriqués deviennent eux aussi en lecture seule avec des types littéraux, jusqu'au niveau le plus profond.

const data = {
  name: 'app',
  tags: ['a', 'b']
} as const;
// tags is readonly ['a', 'b']
console.log(data.name, data.tags[1]);

Assertions const pour les énumérations

Un objet const associé à une union dérivée constitue une alternative légère à enum. Vous obtenez des valeurs littérales à l'exécution et un type exact, sans aucun code supplémentaire généré.

const Status = {
  Idle: 'idle',
  Active: 'active'
} as const;
type Status = typeof Status[keyof typeof Status];
const s: Status = Status.Active;
console.log(s);

Vérification rapide

Évaluez votre compréhension des assertions const.

Récapitulatif : as const

Vous avez appris que as const :

infère le type littéral le plus spécifique, profondément readonly;
transforme les propriétés des objets en champs littéraux en lecture seule ;
transforme les tableaux en tuples en lecture seule de littéraux ;
permet de dériver des unions via typeof arr[number], en maintenant les valeurs et les types synchronisés.

Ensuite, nous combinerons les littéraux en unions expressives.

const LEVELS = ['low', 'mid', 'high'] as const;
type Level = typeof LEVELS[number];
const chosen: Level = 'mid';
console.log(chosen);

Questions Fréquemment Posées

La leçon « Assertions const avec as const » est-elle gratuite ?

Oui — le texte complet de « Assertions const avec as const » 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 « Assertions const avec as const » ?

Figer les objets et les tableaux en types littéraux profondément en lecture seule. 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 3 sur 4.

Combien de temps prend la leçon « Assertions const avec as const » ?

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