Tipos Avançados

TypeScript oferece uma variedade de tipos avançados que permitem aos desenvolvedores criar soluções mais robustas e flexíveis. Entre esses tipos, destacam-se os tipos literais, os tipos union e os tipos intersection. Vamos explorar cada um deles em detalhes.

Tipos Literais

Os tipos literais permitem especificar valores exatos que uma variável pode ter. Em vez de definir um tipo como string, number, etc., você pode restringir o valor a ser exatamente um determinado texto ou número.

Exemplo de Tipos Literais:

type Direction = "up" | "down" | "left" | "right";

let move: Direction;

move = "up"; // válido
move = "left"; // válido
move = "backward"; // inválido, 'backward' não está incluído em Direction

Neste exemplo, a variável move só pode ser uma das quatro direções especificadas, garantindo maior controle sobre os valores que a variável pode assumir.

Tipos Union

Os tipos union permitem que uma variável ou uma função aceite múltiplos tipos. É como dizer "esta variável pode ser de qualquer um desses tipos".

Exemplo de Tipos Union:

let id: number | string;

id = 10; // válido
id = "10"; // válido
id = true; // inválido, apenas number ou string são permitidos

Os tipos union são úteis quando você precisa de flexibilidade para aceitar diferentes tipos de entrada, por exemplo, quando uma função pode lidar tanto com number quanto com string.

Uso com Funções:

function printId(id: number | string) {
  if (typeof id === "number") {
    console.log(`ID number: ${id}`);
  } else {
    console.log(`ID string: ${id}`);
  }
}

printId(101); // Output: ID number: 101
printId("202"); // Output: ID string: 202

Tipos Intersection

Os tipos intersection combinam múltiplos tipos em um único tipo. Uma variável ou objeto que seja de um tipo intersection deve satisfazer todos os tipos combinados.

Exemplo de Tipos Intersection:

interface Person {
  name: string;
  age: number;
}

interface Employee {
  employeeId: number;
}

type EmployeePerson = Person & Employee;

const emp: EmployeePerson = {
  name: "John",
  age: 30,
  employeeId: 12345,
};

Neste exemplo, a variável emp deve satisfazer as propriedades definidas tanto em Person quanto em Employee. Isso é útil quando você precisa combinar diferentes aspectos de tipos em um único objeto.

Combinação de Tipos Avançados

Você pode combinar tipos literais, union e intersection para criar estruturas de tipos ainda mais sofisticadas e específicas.

Exemplo de Combinação:

type Status = "success" | "failure";
type Response = {
  message: string;
};

type APIResponse =
  | (Response & { status: "success"; data: any })
  | (Response & { status: "failure"; error: string });

function handleResponse(response: APIResponse) {
  if (response.status === "success") {
    console.log("Data:", response.data);
  } else {
    console.log("Error:", response.error);
  }
}

const successResponse: APIResponse = {
  status: "success",
  message: "Request was successful",
  data: { id: 1, name: "Test" },
};

const failureResponse: APIResponse = {
  status: "failure",
  message: "Request failed",
  error: "Server error",
};

handleResponse(successResponse); // Output: Data: { id: 1, name: 'Test' }
handleResponse(failureResponse); // Output: Error: Server error

Neste exemplo, APIResponse é um tipo complexo que usa tanto union quanto intersection para definir possíveis formatos de resposta da API.

Conclusão

Os tipos avançados em TypeScript, como tipos literais, union e intersection, proporcionam uma maneira poderosa de definir estruturas de dados precisas e flexíveis. Eles ajudam a garantir a integridade dos dados, facilitam a detecção de erros em tempo de desenvolvimento e tornam o código mais autodescritivo e fácil de manter. 🚀