Apelidos de tipo e interfaces

Boas-vindas à próxima lição! Nesta lição, você aprenderá sobre apelidos de tipo e interfaces em TypeScript, incluindo suas diferenças, semelhanças e quando usar cada um. Vamos começar!

O que são apelidos de tipo?

Um apelido de tipo permite definir um nome personalizado para um tipo. Ele pode representar tipos primitivos, objetos ou até mesmo assinaturas de funções.

Exemplo:

Tarefa: Crie um apelido de tipo para um objeto que represente um livro e use-o para definir uma variável.

type Point = {
  x: number;
  y: number;
};

let point: Point = { x: 10, y: 20 };
console.log(point); 
// Output: { x: 10, y: 20 }

O que são interfaces?

Uma interface define a estrutura de um objeto, incluindo suas propriedades e métodos. Ela é frequentemente usada para garantir a consistência e a segurança de tipos dos objetos.

Exemplo:

Tarefa: Crie uma interface para o perfil de um usuário e use-a para definir uma variável.

interface Point {
  x: number;
  y: number;
}

let point: Point = { x: 5, y: 15 };
console.log(point); 
// Output: { x: 5, y: 15 }

Apelidos de tipo versus interfaces: semelhanças

Os apelidos de tipo e as interfaces compartilham alguns recursos:

• Ambos podem descrever a estrutura de um objeto.
• Ambos podem ser usados para definir tipos de função.
• Ambos permitem estender outros tipos.

Exemplo: Um tipo de função:

Tarefa: Defina um apelido de tipo e uma interface para uma função e use-os.

type Add = (a: number, b: number) => number;
interface Subtract {
  (a: number, b: number): number;
}

let add: Add = (x, y) => x + y;
let subtract: Subtract = (x, y) => x - y;

console.log(add(5, 3)); 
// Output: 8
console.log(subtract(5, 3)); 
// Output: 2

Apelidos de tipo versus interfaces: diferenças

Aqui estão as principais diferenças:

• Interfaces: Podem ser combinadas (fusão de declarações).
• Apelidos de tipo: Não podem ser combinados.
• Apelidos de tipo: Podem definir tipos união e interseção.
• Interfaces: São projetadas principalmente para estruturas de objetos.

Exemplo: Tipos união com apelidos de tipo:

Tarefa: Use um apelido de tipo para definir um tipo união e atribua valores diferentes a uma variável.

type StringOrNumber = string | number;

let value: StringOrNumber = "Hello";
value = 42;
// value = true; 
// Error: Type 'true' is not assignable to type 'StringOrNumber'.

Estendendo tipos e interfaces

Tanto os apelidos de tipo quanto as interfaces podem estender outros tipos:

• Interfaces: Use a palavra-chave extends.
• Apelidos de tipo: Use interseções (&).

Exemplo:

Tarefa: Estenda um apelido de tipo e uma interface para criar novos tipos.

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

type Bird = Animal & { canFly: boolean };

let myDog: Dog = { name: "Buddy", breed: "Golden Retriever" };
let myBird: Bird = { name: "Parrot", canFly: true };

console.log(myDog, myBird);

Fusão de declarações

As interfaces permitem a fusão de declarações, na qual várias declarações de interface com o mesmo nome são combinadas em uma só. Os apelidos de tipo não permitem esse recurso.

Exemplo:

Tarefa: Crie duas declarações de interface com o mesmo nome e teste a fusão de declarações.

interface Person {
  name: string;
}

interface Person {
  age: number;
}

let person: Person = { name: "Alice", age: 30 };
console.log(person); 
// Output: { name: "Alice", age: 30 }

Quando usar cada um

Aqui estão algumas orientações:

• Use interfaces para definir estruturas de objetos e quando for necessária a fusão de declarações.
• Use apelidos de tipo para uniões, interseções ou ao definir tipos de função.

Dica: Use aquele que melhor se adapta ao seu caso de uso, buscando clareza e consistência!

Muito bem!

Parabéns! Você aprendeu as semelhanças e diferenças entre apelidos de tipo e interfaces em TypeScript, além de quando usar cada um. Na próxima lição, exploraremos recursos avançados do TypeScript, como tipos condicionais. Vamos continuar programando!