0Pricing
TypeScript Academy · Lección

Operador de aserción de no nulo

Utilice el operador ! para afirmar que un valor no es null ni undefined.

Operador de aserción de no nulo 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.

El operador de aserción de no nulidad

El operador posfijo ! indica a TypeScript «este valor no es null ni undefined aquí». Elimina esos valores del tipo sin realizar ninguna comprobación en tiempo de ejecución.

function firstChar(s: string | null): string {
  return s!.charAt(0); // assert s is not null
}
console.log(firstChar('hello'));

Dónde colocar el !

El ! va inmediatamente después de la expresión cuya no nulidad está afirmando, antes de cualquier acceso posterior. Elimina null | undefined del tipo de esa expresión.

type Box = { value?: number };
const box: Box = { value: 7 };
const n: number = box.value!; // value is number | undefined -> number
console.log(n);

Afirmar la no nulidad después de una comprobación

A veces ha garantizado lógicamente que un valor está presente, pero el compilador no puede seguir su razonamiento. El ! le permite continuar. Aun así, una comprobación real en tiempo de ejecución suele ser más clara.

const list: Array<string | null> = ['a', null, 'c'];
const present = list.filter((x) => x !== null);
// TS may still see string | null; assert if certain:
console.log(present[0]!.toUpperCase());

Solo en tiempo de compilación, de nuevo

Al igual que as, el operador ! se elimina en tiempo de ejecución. No realiza ninguna comprobación. Si el valor es realmente null, obtendrá un error en tiempo de ejecución aunque el compilador esté satisfecho.

function risky(s: string | null): number {
  return s!.length; // no runtime guard
}
console.log(risky('hi'));
// risky(null) would throw at runtime

El peligro de !

Si afirma que no es nulo un valor que realmente puede ser null, ha creado un error oculto. El compilador deja de advertirle, por lo que el error solo aparece cuando ese null se presenta en producción.

type User = { name?: string };
const u: User = {};
// const len = u.name!.length; // compiles, crashes at runtime
console.log('name is undefined here -> ! would crash');

Prefiera una comprobación real

Siempre que sea práctico, sustituya ! por una comprobación real de null o por el encadenamiento opcional. La versión segura cuesta una línea y elimina toda una categoría de fallos en tiempo de ejecución.

type User = { name?: string };
function nameLen(u: User): number {
  if (u.name) return u.name.length; // checked
  return 0;
}
console.log(nameLen({ name: 'Ada' }), nameLen({}));

Aserción de asignación definida

Una característica relacionada es la aserción de asignación definida: let x!: T. Indica al compilador que x tendrá un valor asignado antes de utilizarse, aunque no se inicialice al declararlo.

let token!: string; // promise: assigned before use
function init() { token = 'abc123'; }
init();
console.log(token.length);

Asignación definida en clases

Esto es habitual en clases donde una propiedad la establece un framework o un método de inicialización en lugar del constructor. El ! que aparece después del nombre de la propiedad silencia el error «no se ha asignado definitivamente».

class Service {
  config!: { url: string }; // set later by setup()
  setup() { this.config = { url: '/api' }; }
}
const s = new Service();
s.setup();
console.log(s.config.url);

Use la asignación definida con cuidado

La aserción de asignación definida es otra promesa que el compilador no puede verificar. Si accede a la propiedad antes de asignarle un valor, leerá undefined en tiempo de ejecución sin recibir ninguna advertencia.

class Late {
  data!: number[];
  read() { return this.data.length; } // crashes if called before init
}
const l = new Late();
l.data = [1, 2];
console.log(l.read());

! frente al encadenamiento opcional

No recurra a ! cuando ?. sea suficiente. El encadenamiento opcional gestiona null de forma segura en tiempo de ejecución, mientras que ! se limita a silenciar el compilador. Resuelven problemas diferentes.

type Cfg = { db?: { host?: string } };
const c: Cfg = {};
console.log(c.db?.host ?? 'localhost'); // safe
// c.db!.host! would crash here

Cuándo está justificado usar !

El operador ! es razonable cuando tiene una garantía real que el compilador no puede expresar; por ejemplo, un valor que acaba de insertar y que lee inmediatamente después. Incluso en ese caso, documente por qué es seguro.

const cache = new Map<string, number>();
cache.set('hits', 0);
// We just set it, so get is non-null:
const hits = cache.get('hits')!;
console.log(hits);

Comprobación rápida

Compruebe cuánto entiende del operador de aserción de no nulidad.

Resumen: aserción de no nulidad

Ha aprendido que:

  • El operador ! posfijo elimina null | undefined de un tipo únicamente en tiempo de compilación.
  • No realiza ninguna comprobación en tiempo de ejecución, por lo que una aserción incorrecta sigue provocando un error.
  • let x!: T es la aserción de asignación definitiva para valores que se inicializan más adelante.
  • Prefiera las comprobaciones reales o el encadenamiento opcional; reserve ! para garantías verdaderas.

A continuación, las aserciones dobles y sus riesgos.

const map = new Map<string, number>();
map.set('a', 1);
const v = map.get('a')!;
console.log(v);

Preguntas frecuentes

¿La lección «Operador de aserción de no nulo» es gratis?

Sí — el texto completo de «Operador de aserción de no nulo» 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 «Operador de aserción de no nulo»?

Utilice el operador ! para afirmar que un valor no es null ni undefined. 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 «Operador de aserción de no nulo»?

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. La palabra clave as para aserciones de tipos
  2. Operador de aserción de no nulo
  3. Aserciones dobles y sus riesgos
  4. Aserciones frente a type guards
← Volver a TypeScript Academy