Aserción de tipos en TypeScript
La aserción de tipos (Type Assertion) es un mecanismo que le dice al compilador: «yo sé mejor que tú cuál es el tipo de este valor». Permite al desarrollador anular manualmente el resultado de la inferencia de tipos de TypeScript, similar a la conversión de tipos en otros lenguajes, perosolo tiene efecto en la fase de compilación y no genera ningún código en tiempo de ejecución.。
Dos formas de sintaxis
La aserción de tipos tiene dos formas de escritura; se recomienda usar de manera uniformeasla sintaxis `as`; la sintaxis de corchetes angulares entrará en conflicto con la sintaxis de etiquetas en archivos JSX.
Ejemplo
const str1: any = "hello";
const len1: number = (<string>str1).length;
// ② Sintaxis as (recomendada)
const str2: any = "world";
const len2: number = (str2 as string).length;
console.log(len1); // 5
console.log(len2); // 5
Resultado de la ejecución:
5 5
Nota:En los archivos de React,
.tsxla sintaxis de corchetes angulares entrará en conflicto con las etiquetas JSX; se debe usarasla sintaxis `as`.
Escenarios de uso comunes
1. Manejar tipos any / unknown
Los datos obtenidos de interfaces externas, análisis JSON y otros escenarios suelen ser de tipoany`any`; mediante la aserción se pueden recuperar las pistas de tipo.
Ejemplo
// Asertar a un tipo concreto para obtener pistas de tipo
const user = response as { name: string; age: number };
console.log(user.name); // Alice
console.log(user.age); // 25
Resultado de la ejecución:
Alice 25
2. Reducir tipos unión
Cuando se conoce la rama concreta de un tipo unión, pero el compilador no puede determinarla automáticamente, se puede usar la aserción para aclarar el tipo.
Ejemplo
| { kind: "circle"; radius: number }
| { kind: "rect"; width: number; height: number };
function getArea(shape: Shape): number {
if (shape.kind === "circle") {
return Math.PI * (shape as { kind: "circle"; radius: number }).radius ** 2;
}
const rect = shape as { kind: "rect"; width: number; height: number };
return rect.width * rect.height;
}
console.log(getArea({ kind: "circle", radius: 5 }).toFixed(2)); // 78.54
console.log(getArea({ kind: "rect", width: 4, height: 6 })); // 24
Resultado de la ejecución:
78.54 24
Consejo:Se prefiere usar guardas de tipo (
typeof/instanceof/ propiedad discriminante) para reducir el tipo; solo use aserciones en escenarios que las guardas no cubren.
3. Manipular elementos del DOM
document.querySelectorLo que devuelve esElement | null`Element | null`; solo después de asertar un tipo de elemento específico se puede acceder a sus propiedades exclusivas.
Ejemplo
const input = document.querySelector("#username") as HTMLInputElement;
// Después de la aserción, se puede acceder a las propiedades exclusivas de HTMLInputElement
// console.log(input.value);
// Forma más segura: primero comprobar si es null y luego asertar
const btn = document.querySelector("#submit");
if (btn) {
(btn as HTMLButtonElement).disabled = true;
}
Aserción de no nulo `!`
Añadir después del valor!`!`, que le dice al compilador que el valor no esnulloundefined`null`/`undefined`; es adecuado para escenarios donde puedas asegurar que no es nulo, pero el compilador no puede inferirlo.
Ejemplo
// Usa ! para asertar que str tiene un valor seguro
console.log(str!.length);
}
// Ejecución normal
printLength("hello"); // 5
// Error en tiempo de ejecución: Cannot read properties of undefined
// printLength();
Resultado de la ejecución:
5
Advertencia:La aserción de no nulo omite la comprobación de valores nulos del compilador; si el valor real es
null/undefined`null`/`undefined`, se seguirá lanzando un error en tiempo de ejecución. Cuando las condiciones lo permitan, priorice el encadenamiento opcional?.`?.` en su lugar.
Aserción de constante `as const`
as constInfiere los literales como el tipo literal de solo lectura más estrecho; se usa a menudo para definir valores de enumeración, constantes de configuración y tuplas.
Ejemplo
const colors1 = ["red", "green", "blue"];
colors1.push("yellow"); // Permitido
// as const: se infiere como readonly ["red", "green", "blue"], ni los elementos ni la longitud se pueden cambiar
const colors2 = ["red", "green", "blue"] as const;
// colors2.push("yellow"); // Error: un array readonly no puede usar push
// Lo mismo para objetos: todas las propiedades se convierten en tipos literales readonly
const config = {
host: "localhost",
port: 3000
} as const;
// config.port = 8080; // Error: las propiedades readonly no se pueden modificar
console.log(colors2); // ['red', 'green', 'blue']
console.log(config.host); // localhost
console.log(config.port); // 3000
Resultado de la ejecución:
['red', 'green', 'blue'] localhost 3000
La aserción no es una conversión de tipos
La aserción de tipos solo afecta a la comprobación de tipos del compilador; después de la compilación no genera ningún código de conversión. Al asertar"42"`str` como `number`,numberen tiempo de ejecución seguirá siendo una cadena.
Ejemplo
// Se aserta como number, pero en tiempo de ejecución sigue siendo string
const wrongNum = strNum as number;
console.log(typeof wrongNum); // string (¡no number!)
console.log(wrongNum + 1); // 421 (concatenación de cadenas, no suma numérica)
// Una conversión de tipos real requiere usar funciones de conversión
const realNum = Number(strNum);
console.log(typeof realNum); // number
console.log(realNum + 1); // 43
Resultado de la ejecución:
string 421 number 43
Doble aserción
Cuando no hay relación de superposición entre dos tipos, TypeScript rechaza la aserción directa. En este caso se puede recurrir aunknown`unknown` como intermediario, pero es una operación peligrosa y debe evitarse en lo posible.
Ejemplo
// Aserción directa: number y string no se superponen; el compilador muestra un error
// const str = num as string;
// Doble aserción: primero asertar como unknown, luego asertar como el tipo deseado
const str = num as unknown as string;
console.log(str); // 42
console.log(typeof str); // number (el tipo en tiempo de ejecución no cambia; la aserción solo tiene efecto en tiempo de compilación)
Resultado de la ejecución:
42 number
Advertencia:La doble aserción omite por completo el sistema de tipos de TypeScript y puede provocar fácilmente errores en tiempo de ejecución. Úsela solo en casos especiales, como cuando los tipos de una biblioteca de terceros no son precisos, y deje constancia del motivo en el código.
Comparación de métodos de aserción
| Método de aserción | Sintaxis | Escenario típico | Riesgo |
|---|---|---|---|
| Aserción `as` | value as Type | Conversión de any a un tipo específico, manipulación del DOM | Bajo (con comprobación de superposición) |
| Aserción de no nulo | value! | Confirmar que no es null/undefined | Medio (omite la comprobación de valores nulos) |
| Aserción de constante | value as const | Constantes literales, valores de enumeración | Ninguno |
| Doble aserción | value as unknown as T | Conversión forzada cuando los tipos no se superponen | Alto (omite por completo la comprobación) |
Resumen
- Elección de sintaxis:Use de manera uniforme
asla sintaxis `as`; evite el uso de corchetes angulares en JSX. - Aserción frente a conversión:La aserción solo afecta al tipo en tiempo de compilación y no genera código en tiempo de ejecución; para una conversión real de valores se necesitan
Number()、String()`Number()`, `String()`, etc. - Aserción de no nulo:Antes de usar
!`!`, asegúrate de que el valor realmente no sea nulo; de lo contrario, se producirá un error en tiempo de ejecución; cuando sea posible, prioriza el uso de `?.`.?. - Aserción de constante:
as constEs una aserción segura y práctica; se recomienda para objetos de configuración y arrays de constantes. - Doble aserción:Es el último recurso; al usarla, se debe explicar el motivo en un comentario.
Otras extensiones