Guardas de tipo en TypeScript

Las guardas de tipo (Type Guards) son un mecanismo de estrechamiento de tipos muy importante en TypeScript.

Permiten a los desarrolladores, mediante comprobaciones de condiciones específicas en tiempo de ejecución, hacer que el compilador de TypeScript pueda inferir con precisión el tipo concreto de una variable.

Con las guardas de tipo, podemos acceder de forma segura a las propiedades y métodos de un tipo específico dentro de una variable de unión.


¿Por qué se necesitan las guardas de tipo?

En TypeScript, una variable puede declararse como una unión de varios tipos.

Cuando necesitamos realizar diferentes operaciones según el tipo, el compilador no puede determinar automáticamente el tipo concreto actual.

Las guardas de tipo son el mecanismo clave para resolver este problema.

Explicación del concepto:El principio central de las guardas de tipo es el "estrechamiento de tipos" (Type Narrowing). Mediante comprobaciones de condiciones, TypeScript reduce automáticamente el tipo de unión a un tipo concreto.


Diagrama SVG: flujo de las guardas de tipo Fondo Título Guarda de tipo - Proceso de estrechamiento de tipos Lado izquierdo: tipo de unión Tipo de unión original string | number | boolean Flecha 1 typeof Centro: typeof string typeof === "string" Estrechado a string Flecha 2 Rama Lado derecho: resultado Tipo determinado Se puede acceder a .length Parte inferior: tipos de guardas de tipo Métodos de guardas de tipo Método 1 typeof typeof x === "string" Tipo primitivo Método 2 instanceof x instanceof Array Instancia de clase Método 3 Guarda personalizada x is String value is Type Método 4 in "prop" in x Comprobación de propiedades Marcador de flecha

typeof como guarda de tipo

typeof es la guarda de tipo más utilizada, se usa para comprobar tipos primitivos (string, number, boolean, etc.).

Devuelve una cadena que representa el tipo del valor.

Uso básico de typeof

// Definir una función que recibe un tipo de unión
// El parámetro value puede ser un string o un número
function printValue(value: string | number): void {
    // Usar typeof para comprobar el tipo
    // Cuando la condición if es true, TypeScript reduce automáticamente value a tipo string
    if (typeof value === "string") {
        // Aquí TypeScript sabe que value es string
        // Se puede acceder de forma segura a la propiedad length del string
        console.log("Longitud de la cadena: " + value.length);
    } else {
        // Al entrar en la rama else, TypeScript sabe que value no es string
        // Solo puede ser de tipo number
        // Se pueden realizar operaciones matemáticas de forma segura
        console.log("Número duplicado: " + (value * 2));
    }
}

// Llamadas de prueba
printValue("hello");  // Pasar un string
printValue(42);       // Pasar un número

Resultado de la ejecución:

字符串长度: 5
数字翻倍: 84

Tipos soportados por typeof:

  • "string"- Tipo string
  • "number"- Tipo number (incluye NaN e Infinity)
  • "boolean"- Tipo boolean
  • "undefined"- Tipo undefined
  • "object"- Tipo object (nota: los arrays y null también se identifican como "object")
  • "function"- Tipo function

Nota:typeof devuelve "object" tanto para arrays como para null. Si necesita distinguir con precisión entre arrays y objetos, debe usar otros métodos.


instanceof como guarda de tipo

instanceof se usa para comprobar si un objeto es una instancia de una clase.

Determina el tipo comprobando la cadena de prototipos del objeto.

Uso básico de instanceof

// Definir la clase Dog
class Dog {
    // Método de ladrido del perro
    bark(): void {
        console.log("¡Guau guau guau!");
    }
}

// Definir la clase Cat
class Cat {
    // Método de maullido del gato
    meow(): void {
        console.log("¡Miau miau miau!");
    }
}

// Función que recibe un tipo de unión
function makeSound(animal: Dog | Cat): void {
    // Usar instanceof para comprobar si animal es Dog o Cat
    // Cuando la condición if es true, TypeScript reduce animal a tipo Dog
    if (animal instanceof Dog) {
        // Ahora se puede llamar al método específico de Dog
        animal.bark();
    } else {
        // En la rama else, TypeScript reduce animal a tipo Cat
        animal.meow();
    }
}

// Llamadas de prueba
makeSound(new Dog());  // Crear una instancia de Dog y llamarla
makeSound(new Cat());  // Crear una instancia de Cat y llamarla

Resultado de la ejecución:

¡Guau guau guau!

Explicación:

instanceof comprueba la cadena de prototipos del objeto, por lo que solo se puede usar con instancias de clase, no con interfaces ni alias de tipo.


Guardas de tipo personalizadas

Cuando typeof e instanceof integrados no son suficientes, se pueden crear funciones de guarda de tipo personalizadas.

Las guardas de tipo personalizadas usanvalue is Typela sintaxis de tipo de retorno.

Funciones de guarda personalizadas

// Definir una función de guarda de tipo personalizada
// El tipo de retorno usa el formato "value is Type"
// Esto le dice a TypeScript: cuando la función devuelve true, el tipo del parámetro es string
function isString(value: any): value is string {
    // Usar typeof para comprobar si es un string
    return typeof value === "string";
}

// Otra guarda personalizada: comprobar si es un número
function isNumber(value: any): value is number {
    return typeof value === "number";
}

// Definir una guarda de tipo array
function isArray(value: any): value is any[] {
    return Array.isArray(value);
}

// Función que procesa el valor
function processValue(value: string | number | any[]): void {
    // Usar guardas personalizadas para la comprobación de tipos
    if (isString(value)) {
        // TypeScript sabe que value es de tipo string
        // Se puede llamar al método toUpperCase()
        console.log("Cadena en mayúsculas: " + value.toUpperCase());
    } else if (isNumber(value)) {
        // TypeScript sabe que value es de tipo number
        // Se puede llamar al método toFixed()
        console.log("Número formateado: " + value.toFixed(2));
    } else if (isArray(value)) {
        // TypeScript sabe que value es de tipo array
        console.log("Longitud del array: " + value.length);
    }
}

// Llamadas de prueba
processValue("hello");
processValue(3.14159);
processValue([1, 2, 3, 4, 5]);

Resultado de la ejecución:

字符串转大写: HELLO
数字格式化: 3.14
数组长度: 5

Consejo:La clave de las guardas de tipo personalizadas es el tipo de retornovalue is Type, que es la marca por la que TypeScript reconoce una guarda de tipo.


El operador in como guarda de tipo

El operador in puede comprobar si un objeto contiene una propiedad.

Si se usa in en una condición, TypeScript reduce automáticamente el tipo del objeto.

Uso del operador in

// Definir dos interfaces con diferentes propiedades
interface A {
    a: string;  // Solo tiene la propiedad a
}

interface B {
    b: number;  // Solo tiene la propiedad b
}

// Función que recibe un tipo de unión
function process(obj: A | B): void {
    // Usar in para comprobar si el objeto contiene la propiedad "a"
    if ("a" in obj) {
        // En la rama if, TypeScript sabe que obj contiene la propiedad a
        // Por lo tanto, el tipo de obj se reduce a A
        console.log("Propiedad a de A: " + obj.a);
    } else {
        // En la rama else, obj no contiene la propiedad a
        // TypeScript sabe que obj solo puede ser de tipo B
        // Por lo tanto, se puede acceder de forma segura a la propiedad b
        console.log("Propiedad b de B: " + obj.b);
    }
}

// Llamadas de prueba
process({ a: "hello" });  // Pasar un objeto con la propiedad a
process({ b: 42 });       // Pasar un objeto con la propiedad b

Resultado de la ejecución:

A 的属性 a: hello
B 的属性 b: 42

Uniones discriminadas y guardas de tipo

La unión discriminada es un patrón poderoso que distingue los miembros de un tipo unión mediante una propiedad común de "identificador".

Combinada con sentencias switch o condiciones if, se puede implementar una guarda de tipo completa.

Calculadora con uniones discriminadas

// Definir la interfaz Circle, usando la propiedad kind como identificador
interface Circle {
    kind: "circle";       // Campo identificador: valor "circle"
    radius: number;       // radio
}

// Definir la interfaz Rectangle
interface Rectangle {
    kind: "rectangle";    // Campo identificador: valor "rectangle"
    width: number;        // ancho
    height: number;      // alto
}

// Definir la interfaz Triangle
interface Triangle {
    kind: "triangle";    // Campo identificador: valor "triangle"
    base: number;        // base
    height: number;      // altura
}

// Definir el tipo unión
type Shape = Circle | Rectangle | Triangle;

// Función para calcular el área
function getArea(shape: Shape): number {
    // Usar una sentencia switch como guarda de tipo
    // Según el valor de la propiedad kind, TypeScript reduce automáticamente el tipo
    switch (shape.kind) {
        case "circle":
            // shape se reduce al tipo Circle
            // Se puede acceder a la propiedad radius
            return Math.PI * shape.radius ** 2;

        case "rectangle":
            // shape se reduce al tipo Rectangle
            // Se puede acceder a las propiedades width y height
            return shape.width * shape.height;

        case "triangle":
            // shape se reduce al tipo Triangle
            return 0.5 * shape.base * shape.height;
    }
}

// Llamada de prueba
var circle = { kind: "circle" as const, radius: 5 };
var rectangle = { kind: "rectangle" as const, width: 4, height: 6 };
var triangle = { kind: "triangle" as const, base: 3, height: 4 };

console.log("Área del círculo: " + getArea(circle).toFixed(2));
console.log("Área del rectángulo: " + getArea(rectangle));
console.log("Área del triángulo: " + getArea(triangle));

Resultado de la ejecución:

圆形面积: 78.54
矩形面积: 24
三角形面积: 6

Explicación:La unión discriminada es uno de los patrones más recomendados en TypeScript. Distingue los diferentes miembros del tipo mediante una propiedad común literal (normalmente kind o type), lo que hace que el código sea seguro en cuanto a tipos y fácil de mantener.


Comprobación de null y undefined

Al manejar valores que pueden ser null o undefined, una comprobación directa de igualdad también es una guarda de tipo válida.

Comprobación de null

// Definir un parámetro de función que puede ser null
function getLength(str: string | null): number {
    // Comprobar directamente que str no es igual a null
    // Cuando la condición es true, TypeScript sabe que str no es null
    // Ahora se puede acceder de forma segura a las propiedades de str
    if (str !== null) {
        return str.length;
    }

    // Manejo del caso null
    return 0;
}

// Llamada de prueba
console.log(getLength("hello"));  // Cadena normal
console.log(getLength(null));      // Pasar null

Resultado de la ejecución:

5
0

Consejo:Con strictNullChecks habilitado, se recomienda realizar siempre la comprobación de null. Se pueden usar el encadenamiento opcional (?.) y la fusión de nulos (??) para simplificar el código.


Estrechamiento por veracidad

Además de la comprobación explícita de tipos, TypeScript también reduce el alcance del tipo mediante la aserción de veracidad (truthiness).

Estrechamiento por veracidad

// Cadena que puede ser undefined
function greet(name?: string): string {
    // Usar operador de cortocircuito: si name es undefined o cadena vacía, usar un valor predeterminado
    // En el bloque de código después de &&, TypeScript sabe que name tiene un valor
    return name && "Hello, " + name;
}

// Prueba
console.log(greet("EJEMPLO"));
console.log(greet());

Resultado de la ejecución:

Hello, EJEMPLO
Hello, undefined

Consideraciones

  • Las guardas de tipo deben usarse en ramas condicionales:TypeScript solo realiza la reducción de tipo después de usar una guarda de tipo en una condición
  • El tipo de retorno debe ser un predicado de tipo:El tipo de retorno de una guarda de tipo personalizada debe servalue is TypeFormato
  • La unión discriminada es una buena práctica:Para tipos unión complejos, se recomienda usar el patrón de unión discriminada
  • Prestar atención a la integridad de la reducción de tipos:Al usar sentencias switch, se recomienda manejar todas las ramas posibles

Sugerencia:Al trabajar con tipos unión, prioriza el uso del patrón de unión discriminada. No solo hace que el código sea más claro, sino que también aprovecha al máximo la capacidad de inferencia de tipos de TypeScript.


Resumen

Las guardas de tipo son una parte importante del sistema de tipos de TypeScript.

  • typeof:La forma más común, adecuada para la comprobación de tipos primitivos.
  • instanceof:Comprobar si un objeto es instancia de una clase específica.
  • Guardas personalizadas:Mediantevalue is Typesintaxis para lograr una comprobación de tipos flexible
  • in:Comprobar si un objeto contiene una propiedad específica
  • Unión discriminada:Patrón recomendado como buena práctica, distingue los tipos mediante un campo identificador
  • Reducción por veracidad:Utilizar la evaluación de veracidad de JavaScript para reducir tipos
Otras extensiones