TypeScript null y undefined
En TypeScript, null y undefined tienen un manejo especial.
Al habilitarstrictNullChecksDespués, es necesario manejar explícitamente estos valores, lo que ayuda a escribir código más seguro.
Diagrama SVG: manejo de null y undefined
Por qué es necesario manejar null y undefined
En JavaScript, null y undefined son una fuente común de errores; muchos errores en tiempo de ejecución están relacionados con ellos.
La opción strictNullChecks de TypeScript exige que los desarrolladores manejen explícitamente los valores que pueden ser nulos.
Aunque esto aumenta el trabajo de codificación, puede reducir en gran medida los errores en tiempo de ejecución causados por valores nulos y mejorar la fiabilidad del código.
Explicación de conceptos:
nullRepresenta "valor nulo", es decir, aquí no hay valor;undefinedRepresenta "indefinido", es decir, aquí aún no se ha asignado un valor.
Fundamentos de null y undefined
null representa "valor nulo" y undefined representa "indefinido". Ambos son tipos independientes en TypeScript.
Ejemplo
// Solo se puede asignar null
var empty: null = null;
// Declarar una variable de tipo undefined
// Solo se puede asignar undefined
var notDefined: undefined = undefined;
console.log("null: " + empty);
console.log("undefined: " + notDefined);
Resultado de la ejecución:
null: null undefined: undefined
Explicación:Sin habilitar strictNullChecks, estos tipos pueden asignarse entre sí. Una vez habilitado, es necesario declararlo explícitamente.
Manejo de null con tipos unión
Después de habilitar strictNullChecks, es necesario usar tipos unión para declarar explícitamente los valores que pueden ser null.
Ejemplo
// Declarar explícitamente que el valor puede ser nulo
var name: string | null = "Alice";
name = null; // Correcto: se puede asignar null
// Acceder a un valor que puede ser null requiere verificación previa
// El parámetro de la función puede ser string o null
function getLength(str: string | null): number {
// Usar una condición para comprobar si es null
if (str === null) {
return 0; // Devuelve 0 si es null
}
// TypeScript infiere que str no es null
return str.length;
}
console.log("Longitud: " + getLength("hello"));
console.log("Longitud: " + getLength(null));
Resultado de la ejecución:
长度: 5 长度: 0
Mejores prácticas:Usar guardas de tipo (comprobaciones if) para estrechar el tipo y que TypeScript sepa exactamente qué tipo es.
Parámetros y propiedades opcionales
Los parámetros y propiedades opcionales incluyen automáticamente undefined; no es necesario declarar null explícitamente.
Ejemplo
// El parámetro puede ser string o undefined
function greet(name?: string): string {
// Comprobar si es undefined
if (name === undefined) {
return "Hello, stranger!";
}
return "Hello, " + name;
}
console.log(greet("Alice"));
console.log(greet());
// Propiedad opcional: se marca con ?
// La propiedad age es opcional, puede no existir
interface User {
name: string;
age?: number; // Propiedad opcional
}
var user: User = { name: "Bob" };
console.log("Usuario: " + JSON.stringify(user));
Resultado de la ejecución:
Hello, Alice!
Hello, stranger!
Usuario: {"name":"Bob"}
Explicación:El parámetro opcional
name?: stringes equivalente astring | undefined。
Operador de aserción no nula
El uso de!le dice al compilador que el valor no es null ni undefined. Esto debe usarse con precaución.
Ejemplo
// Aserción no nula: le dice al compilador que str no es null
// Esto es una forma peligrosa; si str realmente es null, se producirá un error
return str!.length;
}
console.log("Longitud: " + getLength("hello"));
Advertencia:La aserción no nula omite la comprobación de tipos de TypeScript; si el valor realmente es null, se producirá un error en tiempo de ejecución igualmente. Evita usarla en la medida de lo posible.
Operador de coalescencia nula
El uso de??proporciona un valor predeterminado; solo usa el valor predeterminado cuando el valor es null o undefined.
Ejemplo
var name: string | null = null;
// Operador ??: usa el valor de la derecha cuando el lado izquierdo es null/undefined
// Si name es null, usa "Guest"
var displayName = name ?? "Guest";
console.log("Nombre mostrado: " + displayName);
// Comparación con el operador || (trata 0 y cadena vacía como falsy)
var num: number | null = 0;
var result1 = num ?? 100; // 0 (correcto: 0 no es null/undefined)
var result2 = num || 100; // 100 (incorrecto: 0 se considera falsy)
console.log("Resultado de ??: " + result1);
console.log("Resultado de ||: " + result2);
Resultado de la ejecución:
显示名称: Guest ?? 结果: 0 || 结果: 100
Recomendación:Prioriza el uso de
??en lugar de||, porque??solo maneja null y undefined, y no tratará erróneamente 0 ni cadenas vacías como falsy.
Encadenamiento opcional
El uso de?.accede de forma segura a propiedades anidadas que pueden no existir, evitando comprobaciones de valores nulos en múltiples niveles de anidamiento.
Ejemplo
interface Person {
name: string;
address?: {
city: string;
};
}
// Crear un objeto persona sin dirección
var person: Person = { name: "Alice" };
// Encadenamiento opcional: acceder de forma segura a una propiedad que puede no existir
// Si address no existe, devuelve undefined sin lanzar un error
var city = person.address?.city;
// Combinado con el operador de coalescencia nula
console.log("Ciudad: " + city);
console.log("Ciudad: " + (person.address?.city ?? "Desconocido"));
Resultado de la ejecución:
Ciudad: undefined Ciudad: 未知
Mejores prácticas:El encadenamiento opcional
?.es la mejor forma de manejar propiedades opcionales anidadas; combinado con??puede proporcionar un valor predeterminado como respaldo.
Consideraciones
- Modo estricto:Se recomienda habilitar strictNullChecks para obtener una mejor seguridad de tipos
- Evitar aserciones:Evita en lo posible usar la aserción no nula
! - ?? vs ||:Prioriza el uso de ??
??para evitar malinterpretar 0 y cadenas vacías. - Encadenamiento opcional:Al manejar propiedades opcionales anidadas, usa
?.
Mejores prácticas:Usa guardas de tipo, encadenamiento opcional y el operador de coalescencia nula para manejar null y undefined, haciendo que el código sea más seguro y legible.
Resumen
Manejar correctamente null y undefined es clave para escribir código TypeScript seguro.
- Modo estricto:Tras habilitar strictNullChecks, es necesario manejar explícitamente
- Tipos unión:Usar
string | nullpara declarar - Parámetros/propiedades opcionales:Incluyen undefined automáticamente
- Aserción no nula:Usar
!(usar con precaución) - Coalescencia nula:Uso
??Proporcionar un valor predeterminado - Encadenamiento opcional:Uso
?.Acceso seguro
Otras extensionesSugerencia:Adquiere el hábito de manejar valores nulos, utilizando el encadenamiento opcional y el operador de fusión nula para que el código sea más robusto.