Introdução ao refinamento avançado de tipos

O refinamento avançado de tipos permite aperfeiçoar tipos complexos durante a execução usando técnicas avançadas, como proteções de tipo, análise do fluxo de controle e predicados personalizados.

Essas ferramentas tornam seu código TypeScript mais seguro e previsível.

O que é refinamento de tipos?

O refinamento de tipos é o processo de transformar um tipo mais abrangente (por exemplo, string | number) em um tipo mais específico usando verificações durante a execução.

Usando typeof para refinar tipos

O operador typeof pode ser usado para refinar 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

Usando instanceof para refinar tipos

O operador instanceof pode ser usado para refinar instâncias de classes:

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!

Usando proteções de tipo personalizadas

Você pode criar funções personalizadas de proteção de tipos para refiná-los com mais precisão:

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álise do fluxo de controle

A análise do fluxo de controle do TypeScript refina automaticamente os tipos com base no fluxo lógico do seu 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

Benefícios do refinamento avançado de tipos

O refinamento avançado de tipos melhora seu código ao:

• Reduzir erros durante a execução.
• Tornar o código mais seguro e fácil de entender.
• Oferecer controle preciso sobre o tratamento de tipos.

Tarefa prática

Crie uma função que receba um parâmetro do tipo string | number e registre uma mensagem diferente para cada tipo. Use typeof para implementar a lógica.

Parabéns!

Você aprendeu a usar técnicas avançadas de refinamento de tipos no TypeScript para aperfeiçoar e tratar tipos complexos com segurança e eficiência. Pratique essas técnicas para tornar seu código mais robusto e seguro quanto aos tipos!