0Pricing
TypeScript Academy · Lección

null, undefined y comprobaciones estrictas de null

Gestione null y undefined de forma segura mediante el modo estricto.

null, undefined y comprobaciones estrictas de null es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 4 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

En JavaScript, null y undefined son fuentes habituales de errores en tiempo de ejecución. Las comprobaciones estrictas de null de TypeScript le obligan a gestionarlos explícitamente.

null frente a undefined

`undefined` significa que una variable ha sido declarada, pero no se le ha asignado ningún valor. `null` representa una ausencia de valor intencionada. Ambos son tipos independientes en TypeScript.
let a: undefined = undefined;
let b: null = null;

Sin comprobaciones estrictas de null

Sin `strictNullChecks`, null y undefined son subtipos de todos los tipos. Este es el comportamiento predeterminado en las versiones antiguas de TypeScript y, por lo general, no es seguro.
// strictNullChecks: false (unsafe default)
let name: string = null; // allowed — dangerous!

Activar las comprobaciones estrictas de null

Con `strictNullChecks: true` (incluido en `strict`), null y undefined solo se pueden asignar a sus propios tipos o a tipos unión explícitos.
// strictNullChecks: true
let name: string = null; // Error!
let maybeName: string | null = null; // OK

Propiedades opcionales

Las propiedades de objetos marcadas con `?` son implícitamente `T | undefined`. Debe gestionar el caso en que no estén presentes.
interface Config {
  host: string;
  port?: number; // number | undefined
}

const c: Config = { host: 'localhost' };
console.log(c.port?.toString()); // optional chaining

Estrechar tipos anulables

Utilice una comprobación if para estrechar una unión con null o undefined antes de acceder a sus propiedades.
function greet(name: string | null): string {
  if (name === null) return 'Guest';
  return 'Hello, ' + name;
}

Encadenamiento opcional (?.)

El operador `?.` devuelve `undefined` inmediatamente si el lado izquierdo es null o undefined, evitando un error en tiempo de ejecución.
const user = getUser();
const city = user?.address?.city; // undefined if any step is null

Coalescencia nula (??)

El operador `??` devuelve el lado derecho únicamente cuando el lado izquierdo es null o undefined, a diferencia de `||`, que se activa con cualquier valor falsy.
const port = config.port ?? 3000; // 3000 if port is null/undefined
const label = name ?? 'Anonymous';

Operador de aserción no nula (!)

El operador posfijo `!` indica a TypeScript que tiene la certeza de que un valor no es null ni undefined. Utilícelo únicamente cuando esté completamente seguro.
const el = document.getElementById('root')!;
el.textContent = 'Loaded'; // no null check needed

Devolver null frente a undefined

Prefiera devolver `null` para indicar un resultado vacío intencionado y `undefined` para valores ausentes u opcionales. Sea coherente en todo el código.
function findUser(id: number): User | null {
  return db.find(u => u.id === id) ?? null;
}

strictNullChecks evita el error del billón de dólares

Tony Hoare llamó a null su «error del billón de dólares». `strictNullChecks` de TypeScript evita errores por null y undefined al obligarle a gestionar estos valores explícitamente.

Comprobación rápida

¿Qué devuelve el operador `??` (coalescencia nula) en su lado derecho?

Resumen

Active strictNullChecks para evitar errores relacionados con null y undefined. Utilice tipos unión para permitir valores anulables, encadenamiento opcional (?.) para recorrer valores de forma segura y coalescencia nula (??) para proporcionar valores predeterminados.

Preguntas frecuentes

¿La lección «null, undefined y comprobaciones estrictas de null» es gratis?

Sí — el texto completo de «null, undefined y comprobaciones estrictas de null» 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 «null, undefined y comprobaciones estrictas de null»?

Gestione null y undefined de forma segura mediante el modo estricto. 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 4 de 4.

¿Cuánto tiempo toma la lección «null, undefined y comprobaciones estrictas de null»?

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 primitivos: string, number y boolean
  2. El tipo any y por qué evitarlo
  3. unknown frente a any: la opción más segura
  4. null, undefined y comprobaciones estrictas de null
← Volver a TypeScript Academy