TypeScript Academy · Lección

Literales booleanos e inferencia de literales

Comprenda cómo TypeScript amplía o restringe la inferencia de literales.

Literales booleanos e inferencia de literales 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.

Tipos literales booleanos

El tipo boolean es en realidad la unión true | false. Cada uno de ellos es un tipo literal booleano: un tipo que solo permite un valor booleano específico.

let yes: true = true;
let no: false = false;
console.log(yes, no);
// yes = false; // Error: false not assignable to true

Literales booleanos en uniones

Los literales booleanos son especialmente útiles cuando se combinan con otros literales para modelar resultados discriminados, como un indicador de éxito combinado con la forma de los datos.

type Result =
  | { ok: true; value: number }
  | { ok: false; error: string };

const r: Result = { ok: true, value: 42 };
console.log(r);

Ampliación de tipos

Al inicializar una variable, TypeScript decide qué tipo inferir. A veces conserva el literal exacto y otras veces lo amplía al tipo general. Comprender esto es fundamental para obtener tipos predecibles.

const exact = 'hello'; // type: 'hello' (literal)
let broad = 'hello';   // type: string (widened)
console.log(exact, broad);

let se amplía al tipo general

Como una variable let se puede reasignar, TypeScript infiere el tipo general para permitir asignaciones futuras. Una cadena declarada con let comienza como string, no como el literal.

let mood = 'happy'; // inferred as string
mood = 'sad';       // allowed
mood = 'tired';     // allowed
console.log(mood);

const conserva el literal

Una variable const nunca se puede reasignar, por lo que TypeScript infiere el tipo más específico: el literal. Por eso const greeting = 'hi' tiene el tipo 'hi', no string.

const greeting = 'hi'; // type: 'hi'

type Greeting = typeof greeting; // 'hi'
const other: Greeting = 'hi';
console.log(other);

Ampliación con números y booleanos

La misma regla se aplica a los números y los booleanos. const conserva 42 o true como literales; let los amplía a number o boolean.

const n = 42;   // type: 42
const b = true; // type: true
let m = 42;     // type: number
let c = true;   // type: boolean
console.log(n, b, m, c);

Por qué existe la ampliación

La ampliación hace que el código cotidiano sea más práctico. Si cada let count = 0 tuviera el tipo literal 0, no podría incrementarlo. La ampliación permite que las variables reasignables se comporten de forma natural.

let count = 0; // widened to number
count = count + 1;
count = 10;
console.log('Count:', count);

Forzar un literal con una anotación

A veces querrá que una variable let conserve un literal. Añada una anotación explícita de tipo literal y TypeScript lo mantendrá restringido, aunque seguirá permitiendo reasignarlo dentro de esa unión.

let status: 'on' | 'off' = 'on';
status = 'off'; // allowed
console.log(status);
// status = 'paused'; // Error

Ampliación en propiedades de objetos

Las propiedades de los literales de objeto también se amplían de forma predeterminada. Incluso en un objeto const, las propiedades mutables reciben el tipo general, porque la propiedad en sí se puede reasignar.

const config = { mode: 'dark' };
// config.mode has type string, not 'dark'
config.mode = 'light';
console.log(config.mode);

Inferencia de literales con funciones

Los valores de retorno de las funciones también se infieren. Una función que devuelve un valor literal const sigue ampliando su tipo de retorno al tipo general, a menos que lo anote o use tipos literales en la signatura.

function getMode(): 'dark' | 'light' {
  return 'dark';
}

const m = getMode(); // type: 'dark' | 'light'
console.log(m);

Elegir entre tipos literales y generales

Como regla general: use const o anotaciones literales explícitas cuando necesite valores exactos (claves de configuración, discriminadores). Permita el ensanchamiento en las variables mutables habituales. Saber qué tipo obtendrá evita errores inesperados de asignabilidad.

const KEY = 'apiUrl';     // literal 'apiUrl'
let retries = 3;          // number
let level: 'low' | 'high' = 'low'; // pinned literal
console.log(KEY, retries, level);

Comprobación rápida

Compruebe cuánto ha comprendido sobre el ensanchamiento y la inferencia de literales.

Resumen: inferencia de literales

Ideas clave:

true y false son tipos literales; boolean equivale a true | false.
let se ensancha al tipo general (string, number, boolean).
const conserva el tipo literal exacto.
Anote un tipo literal para fijar un let a una unión estrecha.

A continuación, haremos explícita la inmutabilidad con as const.

const literal = 'fixed'; // 'fixed'
let widened = 'fixed';   // string
let pinned: 'a' | 'b' = 'a';
console.log(literal, widened, pinned);

Preguntas frecuentes

¿La lección «Literales booleanos e inferencia de literales» es gratis?

Sí — el texto completo de «Literales booleanos e inferencia de literales» 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 «Literales booleanos e inferencia de literales»?

Comprenda cómo TypeScript amplía o restringe la inferencia de literales. 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 «Literales booleanos e inferencia de literales»?

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

Tipos de literales de cadenas y números
Literales booleanos e inferencia de literales
Aserciones const con as const
Combinación de literales en uniones

← Volver a TypeScript Academy