Tipos de união e interseção TypeScript

O TypeScript fornece recursos poderosos de sistema de tipos que ajudam você a escrever códigos mais seguros e previsíveis. Entre esses recursos estão os tipos union e intersection, que oferecem flexibilidade na definição e no gerenciamento de tipos complexos. Este artigo apresenta esses conceitos e fornece exemplos para ilustrar seu uso.

O que são tipos de união?

Tipos de união permitem que uma variável mantenha valores de tipos diferentes. Isso é útil quando você precisa representar um valor que pode ser um de vários tipos. Tipos de união são denotados usando o símbolo | (pipe).

Definindo Tipos de União

Para definir um tipo de união, você especifica vários tipos separados pelo símbolo |:

let value: string | number;

value = "Hello, TypeScript"; // Valid
value = 42; // Valid
value = true; // Error: Type 'boolean' is not assignable to type 'string | number'

Neste exemplo, a variável valor pode ser uma string ou um número, mas não um booleano.

Usando tipos de união em funções

Os tipos de união são particularmente úteis em funções onde os parâmetros ou tipos de retorno podem ser de vários tipos:

function formatValue(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else {
    return value.toFixed(2);
  }
}

console.log(formatValue("hello")); // Output: HELLO
console.log(formatValue(123.456)); // Output: 123.46

A função formatValue recebe um parâmetro que pode ser uma string ou um number e o formata adequadamente.

O que são tipos de intersecção?

Os tipos de interseção permitem que você combine vários tipos em um. Isso significa que um valor do tipo de interseção satisfará todos os tipos na interseção. Os tipos de interseção são denotados usando o símbolo & (e comercial).

Definindo Tipos de Interseção

Para definir um tipo de interseção, especifique vários tipos separados pelo símbolo &:

interface Person {
  name: string;
}

interface Employee {
  employeeId: number;
}

type EmployeePerson = Person & Employee;

const john: EmployeePerson = {
  name: "John Doe",
  employeeId: 1234
};

console.log(john.name); // Output: John Doe
console.log(john.employeeId); // Output: 1234

Neste exemplo, o tipo EmployeePerson combina as interfaces Person e Employee, resultando em um tipo que tem as propriedades name e employeeId.

Usando tipos de interseção em funções

Tipos de interseção também podem ser usados ​​em funções para exigir múltiplas propriedades de tipo:

function printEmployeeDetails(employee: Person & Employee): void {
  console.log(`Name: ${employee.name}`);
  console.log(`Employee ID: ${employee.employeeId}`);
}

const jane: EmployeePerson = {
  name: "Jane Smith",
  employeeId: 5678
};

printEmployeeDetails(jane);
// Output:
// Name: Jane Smith
// Employee ID: 5678

A função printEmployeeDetails requer um argumento que satisfaça os tipos Person e Employee.

Combinando tipos de união e interseção

Você pode combinar tipos de união e intersecção para criar definições de tipo complexas:

type Shape = Circle | Rectangle;

interface Circle {
  kind: "circle";
  radius: number;
}

interface Rectangle {
  kind: "rectangle";
  width: number;
  height: number;
}

function getArea(shape: Shape): number {
  if (shape.kind === "circle") {
    return Math.PI * shape.radius * shape.radius;
  } else {
    return shape.width * shape.height;
  }
}

const myCircle: Circle = { kind: "circle", radius: 10 };
const myRectangle: Rectangle = { kind: "rectangle", width: 20, height: 30 };

console.log(getArea(myCircle)); // Output: 314.159...
console.log(getArea(myRectangle)); // Output: 600

Neste exemplo, o tipo Shape é uma união de Circle e Rectangle, e a função getArea manipula ambos os tipos adequadamente.

Conclusão

Tipos de união e intersecção no TypeScript fornecem maneiras poderosas de gerenciar e combinar tipos, oferecendo flexibilidade e precisão em definições de tipo. Tipos de união permitem que uma variável seja um de vários tipos, enquanto tipos de intersecção combinam vários tipos em um. Ao usar esses recursos, você pode criar aplicativos mais robustos e seguros para tipos.

Pratique o uso de tipos de união e intersecção para se familiarizar com seus recursos e melhorar suas habilidades de codificação em TypeScript.