Como trabalhar com TypeScript e Promises

O TypeScript aprimora o desenvolvimento de JavaScript adicionando tipos estáticos. Ao trabalhar com código assíncrono, promessas são usadas para manipular operações que serão concluídas no futuro. O TypeScript fornece ferramentas para gerenciar promessas com segurança de tipo e clareza. Este guia explora como trabalhar com promessas no TypeScript, do uso básico a cenários avançados.

Compreendendo Promessas

Uma promessa é um objeto que representa a eventual conclusão ou falha de uma operação assíncrona. Ela fornece métodos para manipular o resultado ou erro da operação. No TypeScript, promessas podem ser digitadas para garantir que sejam resolvidas com o tipo de dado esperado.

Uso básico de promessas

Criar e usar promises em TypeScript é simples. Aqui está um exemplo de uma promise que resolve com uma string:

function fetchData(): Promise {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("Data fetched successfully!");
    }, 1000);
  });
}

fetchData().then((data) => {
  console.log(data); // Outputs: Data fetched successfully!
}).catch((error) => {
  console.error("Error:", error);
});

Neste exemplo, fetchData retorna uma promessa que resolve com uma string. O método then manipula o valor resolvido, enquanto catch manipula quaisquer erros.

Manipulando Promessas com Async/Await

TypeScript suporta a sintaxe async/await, que fornece uma maneira mais legível de trabalhar com promessas. Veja como usar async/await com promessas:

async function fetchDataAsync(): Promise {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("Data fetched successfully!");
    }, 1000);
  });
}

async function processData() {
  try {
    const data = await fetchDataAsync();
    console.log(data); // Outputs: Data fetched successfully!
  } catch (error) {
    console.error("Error:", error);
  }
}

processData();

Neste exemplo, a função fetchDataAsync é declarada como async, permitindo que ela use a palavra-chave await para esperar a resolução da promessa. Erros são capturados usando um bloco try/catch.

Digitando Promessas com Genéricos

O TypeScript permite especificar o tipo de dados com o qual uma promessa resolve usando genéricos. Isso garante que os tipos sejam gerenciados corretamente em todo o código. Aqui está um exemplo de uma promessa tipada:

interface User {
  id: number;
  name: string;
}

function fetchUser(): Promise {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve({ id: 1, name: "John Doe" });
    }, 1000);
  });
}

fetchUser().then((user) => {
  console.log(user.id, user.name); // Outputs: 1 John Doe
}).catch((error) => {
  console.error("Error:", error);
});

Neste exemplo, fetchUser retorna uma promessa que resolve com um objeto User. O tipo é especificado usando genéricos, garantindo a segurança do tipo.

Usando Promises em TypeScript com Chamadas de API

Promises são frequentemente usadas com chamadas de API para manipular busca de dados assíncronos. O sistema de tipos do TypeScript ajuda a gerenciar respostas de APIs:

async function getUserData(userId: number): Promise {
  const response = await fetch(`https://api.example.com/users/${userId}`);
  if (!response.ok) {
    throw new Error("Network response was not ok.");
  }
  const data: User = await response.json();
  return data;
}

getUserData(1).then((user) => {
  console.log(user);
}).catch((error) => {
  console.error("Error:", error);
});

Este exemplo demonstra como usar fetch para fazer uma chamada de API e manipular a resposta usando promises e async/await. A resposta é digitada como User, garantindo a segurança do tipo.

Conclusão

Trabalhar com promessas no TypeScript fornece maior segurança de tipo e clareza para operações assíncronas. Ao usar o sistema de digitação do TypeScript, a sintaxe async/await e genéricos, os desenvolvedores podem gerenciar promessas de forma eficaz e criar aplicativos mais confiáveis.