0Pricing
TypeScript Academy · Lección

Modificadores en tipos mapeados: readonly y ?

Añada o elimine modificadores con +/- en tipos mapeados.

Modificadores en tipos mapeados: readonly y ? es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Bienvenida

Los tipos mapeados pueden añadir o eliminar los modificadores `readonly` y opcional (`?`) de las propiedades mediante los prefijos `+` y `-`.

Adición de modificadores con +

El prefijo `+` (implícito de forma predeterminada) añade un modificador a cada propiedad del tipo mapeado.
type Readonly<T> = { +readonly [K in keyof T]: T[K] }; // + is implicit
type Optional<T> = { [K in keyof T]+?: T[K] };

Eliminación de readonly con -

Use `-readonly` para eliminar el modificador `readonly` de las propiedades.
type Mutable<T> = { -readonly [K in keyof T]: T[K] };
const mutableUser: Mutable<Readonly<User>> = { id: 1, name: 'Alice' };
mutableUser.id = 2; // OK now

Eliminación de ? con -

Use `-?` para eliminar el modificador opcional y hacer que todas las propiedades sean obligatorias.
type Required<T> = { [K in keyof T]-?: T[K] };
// Now all optional properties become required

Combinación de - y -?

Puede combinar ambas eliminaciones para crear una versión mutable y obligatoria de un tipo.
type Concrete<T> = { -readonly [K in keyof T]-?: T[K] };

Partial y Required son opuestos

`Partial` añade `?` con `+?`. `Required` lo elimina con `-?`.
// From TypeScript lib:
type Partial<T> = { [K in keyof T]?: T[K] };   // adds ?
type Required<T> = { [K in keyof T]-?: T[K] };  // removes ?

Conservación predeterminada de modificadores

Sin un `+` o `-` explícito, los tipos mapeados conservan los modificadores existentes del tipo de origen.
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

Uso práctico: tipo Patch

Cree un tipo `Patch` que haga opcionales todas las propiedades y elimine también `readonly` para las actualizaciones.
type Patch<T> = { -readonly [K in keyof T]?: T[K] };

DeepReadonly

Aplique `readonly` de forma recursiva con un tipo condicional dentro del tipo mapeado.
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K]
};

DeepPartial

De forma similar, aplique `?` de forma recursiva para crear un tipo profundamente opcional.
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
};

Tabla de combinaciones de modificadores

+readonly = añadir readonly. -readonly = eliminar readonly. +? = añadir opcional. -? = eliminar opcional. Los cuatro se pueden combinar.

Comprobación rápida

¿Qué produce `{ [K in keyof T]-?: T[K] }`?

Recapitulación

Use los prefijos +/- delante de `readonly` y `?` en los tipos mapeados para añadir o eliminar explícitamente esos modificadores. `-?` implementa `Required` y `-readonly` implementa `Mutable`. Combine ambos para controlar por completo la mutabilidad.

Preguntas frecuentes

¿La lección «Modificadores en tipos mapeados: readonly y ?» es gratis?

Sí — el texto completo de «Modificadores en tipos mapeados: readonly y ?» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Modificadores en tipos mapeados: readonly y ?»?

Añada o elimine modificadores con +/- en tipos mapeados. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Modificadores en tipos mapeados: readonly y ?»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Tipos mapeados: transformación de tipos de objetos
  2. Modificadores en tipos mapeados: readonly y ?
  3. Tipos de literales de plantilla: patrones de texto
  4. Reasignación de claves con as en tipos mapeados
← Volver a TypeScript Academy