0Pricing
TypeScript Academy · Leçon

Assertions const et as const

Utilisez as const pour déduire précisément les types littéraux et de tuples

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

as const est une assertion de type qui indique à TypeScript de déduire les types littéraux les plus spécifiques possibles pour une expression et de rendre toutes les propriétés readonly.

const colors = ["red", "green", "blue"] as const;
// type: readonly ["red", "green", "blue"]

Empêcher l’élargissement avec as const

Sans as const, les valeurs de chaîne dans les tableaux et les objets sont élargies en string. Avec cette assertion, elles conservent leur type littéral.

const dir1 = { direction: "left" };
// dir1.direction: string

const dir2 = { direction: "left" } as const;
// dir2.direction: "left"

as const sur les littéraux d’objet

Chaque propriété d’un objet utilisant as const devient readonly et conserve récursivement son type littéral.

const theme = {
  color: "dark",
  sizes: { sm: 8, md: 16 },
} as const;
// theme.color: "dark", theme.sizes.sm: 8 (all readonly)

as const pour les types tuple

Les tableaux utilisant as const deviennent des tuples readonly dont les éléments ont des types littéraux, ce qui est utile pour définir des listes d’arguments fixes.

const args = [1, "hello", true] as const;
// type: readonly [1, "hello", true]

Dériver des types union avec as const

Modèle courant : définissez un tableau de valeurs avec as const, puis dérivez-en un type union à l’aide de typeof et d’un accès indexé.

const STATUSES = ["pending", "active", "done"] as const;
type Status = typeof STATUSES[number];
// type Status = "pending" | "active" | "done"

as const dans les arguments de fonction

Vous pouvez utiliser as const directement lors de l’appel d’une fonction afin de préserver les types littéraux au-delà de la limite de l’appel.

function setMode(mode: "dark" | "light") {}
setMode("dark" as const); // safe, preserves literal

Récursivité de Readonly

as const applique Readonly récursivement. Les objets et les tableaux imbriqués deviennent tous readonly, ce qui empêche les mutations profondes.

const config = { db: { host: "localhost", port: 5432 } } as const;
// config.db.port = 5433; // Error: readonly

as const et Object.freeze

as const est une assertion lors de la compilation, sans protection à l’exécution. Object.freeze agit à l’exécution. Ces deux mécanismes ont des rôles complémentaires.

const obj = Object.freeze({ x: 1 }); // runtime immutability
const obj2 = { x: 1 } as const;      // compile-time literal types

Assertions de constantes et annotations de types

Une annotation de type élargit le type : const x: string = "hi" donne le type string. as const le restreint : const x = "hi" as const donne "hi".

const a: string = "hi"; // type: string
const b = "hi" as const; // type: "hi"

Utilisation pratique : objets semblables à des énumérations

De nombreuses bases de code utilisent des objets as const comme alternative aux énumérations, ce qui évite leurs écueils tout en conservant la sûreté des types.

const Direction = { Up: "UP", Down: "DOWN" } as const;
type Direction = typeof Direction[keyof typeof Direction];
// "UP" | "DOWN"

Récapitulatif : as const

as const amène TypeScript à inférer des types littéraux et à traiter toutes les propriétés comme en lecture seule. Cette construction est essentielle pour dériver des types d’union précis à partir de tableaux et créer des objets de configuration sûrs.

Vérification rapide

Que fait as const à un tableau ?

Ce que vous avez appris

as const est un outil puissant pour figer les types littéraux, créer des structures en lecture seule et dériver des types d’union précis à partir de tableaux. C’est un élément fondamental des modèles avancés de TypeScript.

Questions Fréquemment Posées

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

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

Utilisez as const pour déduire précisément les types littéraux et de tuples 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 4 sur 4.

Combien de temps prend la leçon « Assertions const et 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

  1. Mécanismes d’élargissement et d’affinement des types
  2. Typage contextuel : déduction depuis le contexte
  3. Fraîcheur et vérification des propriétés superflues
  4. Assertions const et as const
← Retour à TypeScript Academy