0Pricing
TypeScript Academy · Leçon

Modificateurs des types mappés : readonly et ?

Ajoutez ou supprimez des modificateurs avec +/- dans les types mappés

Modificateurs des types mappés : readonly et ? 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.

Bienvenue

Les types mappés peuvent ajouter ou supprimer les modificateurs `readonly` et facultatif (`?`) des propriétés à l’aide des préfixes `+` et `-`.

Ajouter des modificateurs avec +

Le préfixe `+` (implicite par défaut) ajoute un modificateur à chaque propriété du type mappé.
type Readonly<T> = { +readonly [K in keyof T]: T[K] }; // + is implicit
type Optional<T> = { [K in keyof T]+?: T[K] };

Supprimer readonly avec -

Utilisez `-readonly` pour retirer le modificateur readonly des propriétés.
type Mutable<T> = { -readonly [K in keyof T]: T[K] };
const mutableUser: Mutable<Readonly<User>> = { id: 1, name: 'Alice' };
mutableUser.id = 2; // OK now

Supprimer ? avec -

Utilisez `-?` pour supprimer le modificateur facultatif et rendre toutes les propriétés obligatoires.
type Required<T> = { [K in keyof T]-?: T[K] };
// Now all optional properties become required

Combiner - et -?

Vous pouvez combiner ces deux suppressions pour créer une version modifiable et obligatoire d’un type.
type Concrete<T> = { -readonly [K in keyof T]-?: T[K] };

Partial et Required sont opposés

Partial ajoute `?` avec +?. Required le supprime avec -?.
// From TypeScript lib:
type Partial<T> = { [K in keyof T]?: T[K] };   // adds ?
type Required<T> = { [K in keyof T]-?: T[K] };  // removes ?

Préservation des modificateurs par défaut

Sans `+` ou `-` explicite, les types mappés préservent les modificateurs existants du type source.
interface User { readonly id: number; name?: string; }
type Copy<T> = { [K in keyof T]: T[K] };
type C = Copy<User>; // readonly id preserved, name? preserved

Utilisation pratique : type Patch

Créez un type Patch qui rend toutes les propriétés facultatives et supprime également readonly pour permettre les mises à jour.
type Patch<T> = { -readonly [K in keyof T]?: T[K] };

DeepReadonly

Appliquez readonly récursivement avec un type conditionnel à l’intérieur du type mappé.
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K]
};

DeepPartial

De même, appliquez ? récursivement pour obtenir un type profondément facultatif.
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
};

Tableau des combinaisons de modificateurs

+readonly = ajouter readonly. -readonly = supprimer readonly. +? = ajouter le caractère facultatif. -? = supprimer le caractère facultatif. Les quatre peuvent être combinés.

Vérification rapide

Que produit `{ [K in keyof T]-?: T[K] }` ?

Récapitulatif

Utilisez les préfixes +/- devant readonly et ? dans les types mappés pour ajouter ou supprimer explicitement ces modificateurs. -? implémente Required et -readonly implémente Mutable. Combinez-les pour contrôler entièrement la mutabilité.

Questions Fréquemment Posées

La leçon « Modificateurs des types mappés : readonly et ? » est-elle gratuite ?

Oui — le texte complet de « Modificateurs des types mappés : readonly et ? » 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 « Modificateurs des types mappés : readonly et ? » ?

Ajoutez ou supprimez des modificateurs avec +/- dans les types mappés 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 « Modificateurs des types mappés : readonly et ? » ?

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. Types mappés : transformer les types d’objets
  2. Modificateurs des types mappés : readonly et ?
  3. Types littéraux de modèle : motifs textuels
  4. Remappage des clés avec as dans les types mappés
← Retour à TypeScript Academy