Introducción al estrechamiento avanzado de tipos

El estrechamiento avanzado de tipos permite refinar tipos complejos en tiempo de ejecución mediante técnicas avanzadas como las guardas de tipo, el análisis del flujo de control y los predicados personalizados.

Estas herramientas hacen que su código de TypeScript sea más seguro y predecible.

¿Qué es el estrechamiento de tipos?

El estrechamiento de tipos es el proceso de refinar un tipo más amplio (por ejemplo, string | number) para convertirlo en un tipo más específico mediante comprobaciones en tiempo de ejecución.

Usar typeof para estrechar tipos

El operador typeof se puede usar para estrechar tipos primitivos:

function printValue(value: string | number): void {
  if (typeof value === 'string') {
    console.log(`String: ${value}`);
  } else {
    console.log(`Number: ${value}`);
  }
}

printValue('Hello'); // String: Hello
printValue(42); // Number: 42

Usar instanceof para estrechar tipos

El operador instanceof se puede usar para estrechar instancias de clases:

class Dog {
  bark() {
    console.log('Woof!');
  }
}

class Cat {
  meow() {
    console.log('Meow!');
  }
}

function makeSound(animal: Dog | Cat): void {
  if (animal instanceof Dog) {
    animal.bark();
  } else {
    animal.meow();
  }
}

makeSound(new Dog()); // Woof!
makeSound(new Cat()); // Meow!

Usar guardas de tipo personalizadas

Puede crear funciones de guarda de tipo personalizadas para estrechar tipos con mayor precisión:

type Fish = { swim: () => void };
type Bird = { fly: () => void };

declare const animal: Fish | Bird;

function isFish(animal: Fish | Bird): animal is Fish {
  return (animal as Fish).swim !== undefined;
}

if (isFish(animal)) {
  animal.swim();
} else {
  animal.fly();

Análisis del flujo de control

El análisis del flujo de control de TypeScript estrecha automáticamente los tipos en función del flujo lógico del código:

function getLength(value: string | string[]): number {
  if (Array.isArray(value)) {
    return value.length;
  } else {
    return value.length;
  }
}

console.log(getLength('Hello')); // 5
console.log(getLength(['a', 'b', 'c'])); // 3

Ventajas del estrechamiento avanzado de tipos

El estrechamiento avanzado de tipos mejora su código al:

• Reducir los errores en tiempo de ejecución.
• Hacer que el código sea más seguro y fácil de entender.
• Proporcionar un control preciso sobre la gestión de tipos.

Tarea práctica

Cree una función que reciba un parámetro de tipo string | number y registre un mensaje diferente para cada tipo. Use typeof para implementar la lógica.

¡Enhorabuena!

Ha aprendido a usar técnicas avanzadas de estrechamiento de tipos en TypeScript para refinar y gestionar tipos complejos de forma segura y eficaz. ¡Practique estas técnicas para que su código sea más robusto y seguro en cuanto a tipos!