TypeScript é uma linguagem fortemente tipada que adiciona tipos ao JavaScript, ajudando a evitar erros de tipagem e tornando o código mais fácil de manter. Neste tutorial, vamos explorar como tipar funções, objetos e classes em TypeScript.

1. Tipando Funções

No TypeScript, podemos definir o tipo de parâmetros e o tipo de retorno de uma função. Isso nos dá mais controle e segurança no código.

Sintaxe Básica:

function sum(a: number, b: number): number {
  return a + b;
}

Explicação:

  • a: number e b: number tipam os parâmetros como números.
  • : number após os parênteses indica que a função deve retornar um número.

Se tentarmos passar um argumento que não seja número, o TypeScript nos alertará sobre o erro.

Exemplo com Funções Anônimas:

const multiply = (x: number, y: number): number => {
  return x * y;
};

Aqui usamos a mesma lógica, mas com uma função anônima (arrow function).

Funções com Parâmetros Opcionais:

Às vezes, precisamos de parâmetros que não são obrigatórios. Para isso, usamos o símbolo ?.

function greet(name: string, age?: number): string {
  if (age) {
    return `Hello, ${name}. You are ${age} years old.`;
  }
  return `Hello, ${name}.`;
}
  • age?: number torna o parâmetro age opcional.

2. Tipando Objetos

No TypeScript, podemos definir a estrutura de um objeto usando interfaces ou type aliases.

Usando type para Objetos:

type User = {
  name: string;
  age: number;
  isAdmin: boolean;
};

const user: User = {
  name: "John",
  age: 30,
  isAdmin: true,
};

Explicação:

  • Definimos o tipo User com três propriedades: name, age, e isAdmin.
  • Quando criamos o objeto user, ele deve seguir essa estrutura.

Usando Interfaces:

Uma outra maneira de tipar objetos é através de interfaces. A vantagem é que podemos estender interfaces.

interface Car {
  model: string;
  year: number;
  isElectric: boolean;
}

const myCar: Car = {
  model: "Tesla Model S",
  year: 2021,
  isElectric: true,
};

As interfaces são muito semelhantes a type, mas podem ser mais flexíveis, especialmente ao trabalhar com herança.

3. Tipando Classes

Em TypeScript, as classes também podem ser tipadas de maneira robusta. Podemos definir os tipos de propriedades e métodos.

class Animal {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  speak(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

const dog = new Animal("Buddy", 3);
dog.speak(); // Output: Buddy makes a sound.

Explicação:

  • As propriedades name e age são tipadas como string e number, respectivamente.
  • O método speak não retorna nada (void).

4. Tipos Combinados e União

TypeScript permite criar tipos mais complexos usando uniões ou interseções.

União (Union):

Uma união permite que um valor tenha mais de um tipo.

function printId(id: number | string): void {
  console.log(`Your ID is: ${id}`);
}

printId(101);  // Válido
printId("202"); // Válido

Aqui, o parâmetro id pode ser um number ou string.

Interseção (Intersection):

Já a interseção combina vários tipos em um.

type Admin = {
  name: string;
  permissions: string[];
};

type Employee = {
  name: string;
  department: string;
};

type AdminEmployee = Admin & Employee;

const admin: AdminEmployee = {
  name: "Alice",
  permissions: ["edit", "delete"],
  department: "IT",
};

Neste exemplo, AdminEmployee combina as propriedades de Admin e Employee.

Conclusão

Neste guia, abordamos os fundamentos de como usar tipos em funções, objetos e classes em TypeScript. Usar tipos ajuda a garantir que o código esteja correto, fácil de manter e menos propenso a erros.

Resumo:

  1. Tipar funções ajuda a evitar erros de parâmetro e retorno.
  2. Tipar objetos garante que eles sigam uma estrutura específica.
  3. Classes em TypeScript podem ser fortemente tipadas para facilitar o desenvolvimento.
  4. Tipos avançados, como uniões e interseções, aumentam a flexibilidade e segurança do código.