10 Melhores práticas para dominar o TypeScript

Se você é um desenvolvedor que deseja escrever código mais robusto, sustentável e escalável, então o TypeScript pode ser a linguagem de programação que você está procurando. Com o TypeScript, é possível detectar possíveis erros antes mesmo de eles acontecerem, permitindo que você escreva um código mais seguro. No entanto, para aproveitar ao máximo o TypeScript e escrever projetos de alta qualidade, é essencial seguir as práticas recomendadas.

Neste artigo, vamos explorar as 20 melhores práticas para dominar o TypeScript, incluindo emojis, citações, exemplos de código e links para ajudá-lo a aprofundar cada tópico.

1. Verificação rigorosa de tipo 🕵️‍♂️

A verificação rigorosa de tipo no TypeScript ajuda a capturar bugs sorrateiros que podem entrar no seu código e causar problemas futuros. É importante garantir que os tipos de suas variáveis correspondam aos tipos que você espera que sejam, e isso é fácil de habilitar. Basta adicionar "strict": true ao seu arquivo tsconfig.json.

let userName: string = "João";
userName = 123; // O TypeScript gerará um erro porque "123" não é uma string.

2. Inferência de tipo 🤖

O TypeScript é tudo sobre ser explícito com seus tipos, mas isso não significa que você precise soletrar tudo. A inferência de tipo é a capacidade do compilador TypeScript de determinar automaticamente o tipo de uma variável com base no valor atribuído a ela.

let name = "João";

3. Linters 🧹

Os Linters são ferramentas que podem ajudá-lo a escrever um código melhor, aplicando um conjunto de regras e diretrizes. Eles podem ajudá-lo a detectar possíveis erros e melhorar a qualidade geral do seu código. O TSLint e o ESLint são alguns dos linters disponíveis para o TypeScript.

4. Interfaces 📑

As interfaces em TypeScript definem um contrato para a forma de um objeto. Elas especificam as propriedades e métodos que um objeto desse tipo deve ter e podem ser usadas como um tipo para uma variável. Isso ajuda a garantir que o objeto esteja seguindo a estrutura esperada.

interface User {
  name: string;
  age: number;
  email: string;
}

function sendEmail(user: User) {
  // ...
}

const newUser = {
  name: "João",
  age: 30,
};

sendEmail(newUser); // O TypeScript gerará um erro porque a propriedade "email" está faltando.

5. Tipos de Union 🤝

Os tipos de Union no TypeScript permitem que uma variável possa ter mais de um tipo. Isso pode ser útil quando você deseja que uma função possa aceitar diferentes tipos de parâmetros.

function getUser(id: number | string) {
  // ...
}

6. Type Guards 🛡️

Os Type Guards permitem que você verifique se uma variável é de um determinado tipo. Isso é útil quando você tem uma variável que pode ser de mais de um tipo e precisa executar a lógica de acordo com o tipo real da variável.

function isString(value: any): value is string {
  return typeof value === "string";
}

function example(value: string | number) {
  if (isString(value)) {
    console.log(value.toUpperCase());
  } else {
    console.log(value.toFixed(2));
  }
}

7. Módulos 📦

Os módulos em TypeScript ajudam a organizar seu código em arquivos separados e a importar/exportar funcionalidades entre eles. Isso ajuda a manter seu código limpo e modular, o que pode facilitar a manutenção e o teste.

// file1.ts
export function sum(a: number, b: number) {
  return a + b;
}

// file2.ts
import { sum } from "./file1";
console.log(sum(2, 3)); // Output: 5

8. Enums 🌐

Os Enums em TypeScript são uma maneira de definir um conjunto de valores nomeados. Eles podem ser usados para melhorar a legibilidade do código e evitar erros de digitação. Além disso, o TypeScript compila os enums em código JavaScript otimizado para desempenho.

enum Color {
  Red,
  Green,
  Blue,
}

console.log(Color.Red); // Output: 0
console.log(Color[1]); // Output: Green

9. Generics 🦄

Os Generics em TypeScript permitem que você escreva funções e classes que podem trabalhar com vários tipos de dados. Isso pode tornar seu código mais flexível e reutilizável. Os generics são frequentemente usados em bibliotecas e frameworks.

function identity<T>(value: T): T {
  return value;
}

console.log(identity("hello")); // Output: "hello"
console.log(identity(42)); // Output: 42

10. Testes Unitários 🧪

Os testes unitários são uma prática comum no desenvolvimento de software e são uma maneira eficaz de garantir que seu código funcione como esperado. Existem várias estruturas de teste para o TypeScript, como o Jest, o Mocha e o Jasmine. Escrever testes unitários pode ajudar a identificar problemas no código antes que eles se tornem problemas reais para os usuários finais.

“O espaço entre a teoria e a prática não é tão grande como é, a teoria na prática.”
Autor desconhecido