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

// ① Sintaxis de corchetes angulares (no recomendada; no se puede usar en archivos .tsx)
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

const response: any = { name: "Alice", age: 25 };

// 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

type Shape =
    | { 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

// querySelector devuelve Element | null
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

function printLength(str?: string) {
    // 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 esnull / 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

// Declaración normal: se infiere como string[], los elementos se pueden modificar
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

const strNum: any = "42";

// 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

const num = 42;

// 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 TypeConversión de any a un tipo específico, manipulación del DOMBajo (con comprobación de superposición)
Aserción de no nulovalue!Confirmar que no es null/undefinedMedio (omite la comprobación de valores nulos)
Aserción de constantevalue as constConstantes literales, valores de enumeraciónNinguno
Doble aserciónvalue as unknown as TConversión forzada cuando los tipos no se superponenAlto (omite por completo la comprobación)

Resumen

  • Elección de sintaxis:Use de manera uniformeasla 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 necesitanNumber()、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