Aulas

Curso de Javascript – Aula 7 | Callbacks e Promises

12 meses atrás

Neste módulo, vamos explorar dois conceitos fundamentais em JavaScript para lidar com operações assíncronas de maneira eficiente: Callbacks e Promises. Enfim, o JavaScript opera como uma linguagem de programação baseada em eventos e operações assíncronas, o que implica que frequentemente nós realizamos tarefas que demandam tempo para sua conclusão, como carregar dados, fazer requisições de rede ou ler/gravar arquivos.

Os Callbacks são uma das formas mais tradicionais de lidar com operações assíncronas em JavaScript. Eles passam funções como argumentos para outras funções e as executam após a conclusão de uma operação assíncrona. As pessoas amplamente utilizam as Callbacks, mas elas podem levar ao “callback hell”, que torna o código difícil de ler e manter devido ao aninhamento excessivo de callbacks

Para solucionar esse problema, surgem as Promises, uma abordagem mais moderna e elegante para lidar com operações assíncronas em JavaScript. Ou seja, as Promises são objetos que representam o resultado eventual (sucesso ou falha) de uma operação assíncrona. Elas permitem um encadeamento mais limpo e estruturado de operações assíncronas, melhorando a legibilidade e a organização do código.

Neste módulo, vamos aprender como utilizar Callbacks e Promises para tratar operações assíncronas, encadear tarefas em sequência e lidar com tratamento de erros de forma controlada. Enfim, compreender esses conceitos é fundamental para criar aplicações web mais eficientes, responsivas e confiáveis. Vamos mergulhar no mundo das Callbacks e Promises e elevar nossas habilidades em desenvolvimento JavaScript para um novo patamar!

Tratamento de Operações Assíncronas com Callbacks

Nesta aula, vamos explorar como lidar com operações assíncronas em JavaScript usando callbacks. Operações assíncronas ocorrem quando executamos tarefas que levam algum tempo para serem concluídas, como carregamento de arquivos, requisições de rede ou operações de leitura/gravação de dados em bancos de dados. Para evitar que a execução do código seja bloqueada enquanto aguardamos a conclusão dessas tarefas, utilizamos callbacks para indicar o que deve ser feito quando a operação assíncrona for finalizada.

O que são Callbacks

Você passa callbacks como funções que executam após a conclusão de uma operação assíncrona. Ao finalizar uma tarefa assíncrona, chamamos a função de callback para tratar o resultado ou continuar a execução do código.

Exemplo de uso de Callbacks para operação assíncrona:
function carregarDados(url, callback) {
  // Simula uma requisição de rede
  setTimeout(function() {
    const dados = { nome: "João", idade: 30 };
    callback(dados);
  }, 2000); // Espera 2 segundos antes de chamar o callback
}

function exibirDados(dados) {
  console.log(`Nome: ${dados.nome}, Idade: ${dados.idade}`);
}

carregarDados("https://exemplo.com/dados", exibirDados);

Tratamento de Erros com Callbacks

Você pode usar callbacks também para lidar com erros em operações assíncronas. O callback pode usar um padrão comum, reservando o primeiro parâmetro para o erro, enquanto os demais parâmetros contêm os resultados da operação.

Exemplo de tratamento de erros com Callbacks:
function lerArquivo(caminho, callback) {
  // Simula a leitura de um arquivo
  setTimeout(function() {
    const erro = null; // Define o erro como nulo para simular sucesso
    const conteudo = "Conteúdo do arquivo";
    callback(erro, conteudo);
  }, 3000); // Espera 3 segundos antes de chamar o callback
}

function exibirConteudo(erro, conteudo) {
  if (erro) {
    console.error("Erro ao ler o arquivo:", erro);
  } else {
    console.log("Conteúdo:", conteudo);
  }
}

lerArquivo("arquivo.txt", exibirConteudo);

Os callbacks são uma abordagem comum para lidar com operações assíncronas em JavaScript, permitindo que o código continue a execução sem bloqueios enquanto aguarda a conclusão das tarefas. Eles utilizam em muitas situações, como redes de requisições, leitura/gravação de arquivos e acesso a bancos de dados. No entanto, à medida que o código cresce, o uso excessivo de callbacks pode levar a problemas de legibilidade e manutenção. Por isso, em futuras aulas, exploraremos outras técnicas, como Promises e async/await, que tornam a escrita de código assíncrono mais elegante e organizada. Continue praticando e explorando as possibilidades dos callbacks para aprimorar suas habilidades em desenvolvimento web com JavaScript.

Utilização de Promises para Lidar com Fluxos de Dados Assíncronos

Nesta aula, vamos explorar o uso de Promises em JavaScript para lidar com fluxos de dados assíncronos de forma mais elegante e organizada. As Promises são uma alternativa moderna aos callbacks, que nos permitem lidar com operações assíncronas de maneira mais clara, facilitando a leitura e manutenção do código.

O que são Promises

Uma Promise é um objeto que representa o resultado eventual (sucesso ou falha) de uma operação assíncrona. Ela pode estar em três estados: pendente (pending), resolvida (fulfilled) ou rejeitada (rejected). Quando a operação é concluída, a Promise é resolvida ou rejeitada, e podemos utilizar os métodos then() e catch() para lidar com o resultado.

Exemplo de criação de uma Promise:
function carregarDados(url) {
  return new Promise(function(resolve, reject) {
    // Simula uma requisição de rede
    setTimeout(function() {
      const dados = { nome: "João", idade: 30 };
      resolve(dados); // Promise é resolvida com sucesso
      // Ou para simular um erro:
      // reject("Erro ao carregar os dados");
    }, 2000); // Espera 2 segundos antes de resolver a Promise
  });
}

const promise = carregarDados("https://exemplo.com/dados");

Tratamento de Sucesso e Erro com Promises

Para lidar com o resultado de uma Promise, utilizamos os métodos then() para o tratamento de sucesso e catch() para o tratamento de erro. O método then() recebe uma função de callback que será chamada quando a Promise for resolvida com sucesso, enquanto o método catch() recebe uma função de callback que será chamada quando a Promise for rejeitada.

Exemplo de tratamento de sucesso e erro com Promises:
function exibirDados(dados) {
  console.log(`Nome: ${dados.nome}, Idade: ${dados.idade}`);
}

function tratarErro(erro) {
  console.error("Erro ao carregar os dados:", erro);
}

const promise = carregarDados("https://exemplo.com/dados");
promise.then(exibirDados).catch(tratarErro);

Encadeamento de Promises

As Promises também permitem o encadeamento de múltiplas operações assíncronas, tornando o código mais legível e evitando o “callback hell” (aninhamento excessivo de callbacks).

Exemplo de encadeamento de Promises:
function carregarDados(url) {
  return new Promise(function(resolve, reject) {
    // Simula uma requisição de rede
    setTimeout(function() {
      const dados = { nome: "João", idade: 30 };
      resolve(dados); // Promise é resolvida com sucesso
    }, 2000); // Espera 2 segundos antes de resolver a Promise
  });
}

function buscarDetalhesUsuario(usuario) {
  return new Promise(function(resolve) {
    // Simula uma busca de detalhes adicionais do usuário
    setTimeout(function() {
      usuario.profissao = "Desenvolvedor";
      resolve(usuario);
    }, 1000); // Espera 1 segundo antes de resolver a Promise
  });
}

carregarDados("https://exemplo.com/dados")
  .then(buscarDetalhesUsuario)
  .then(exibirDados)
  .catch(tratarErro);

O uso de Promises em JavaScript simplifica a lida com operações assíncronas, tornando o código mais organizado, legível e menos propenso a erros. O encadeamento de Promises também nos permite executar uma sequência de operações assíncronas de forma clara e eficiente. As Promises são uma ferramenta poderosa para trabalhar com fluxos de dados assíncronos, e em futuras aulas, exploraremos ainda mais recursos, como as funções async/await, que trazem ainda mais praticidade para a manipulação de operações assíncronas em JavaScript. Continue praticando e aprimorando suas habilidades com Promises para elevar o nível de suas aplicações web!

Encadeamento de Promises e Tratamento de Erros

Nesta aula, vamos continuar explorando o encadeamento de Promises em JavaScript e como lidar com o tratamento de erros de forma mais elegante. O encadeamento de Promises nos permite executar sequências de operações assíncronas de maneira mais clara e concisa, enquanto o tratamento de erros nos ajuda a lidar com falhas nas operações assíncronas de forma controlada.

Encadeamento de Promises

O encadeamento de Promises é uma técnica que nos permite executar várias operações assíncronas em sequência, sem aninhamento excessivo de callbacks. Isso torna o código mais legível e facilita a compreensão das operações que estão sendo realizadas.

Exemplo de encadeamento de Promises:
function carregarDados(url) {
  return new Promise(function(resolve, reject) {
    // Simula uma requisição de rede
    setTimeout(function() {
      const dados = { nome: "João", idade: 30 };
      resolve(dados); // Promise é resolvida com sucesso
    }, 2000); // Espera 2 segundos antes de resolver a Promise
  });
}

function buscarDetalhesUsuario(usuario) {
  return new Promise(function(resolve) {
    // Simula uma busca de detalhes adicionais do usuário
    setTimeout(function() {
      usuario.profissao = "Desenvolvedor";
      resolve(usuario);
    }, 1000); // Espera 1 segundo antes de resolver a Promise
  });
}

carregarDados("https://exemplo.com/dados")
  .then(buscarDetalhesUsuario)
  .then(function(usuario) {
    console.log(`Nome: ${usuario.nome}, Profissão: ${usuario.profissao}`);
  })
  .catch(function(erro) {
    console.error("Erro ao carregar os dados:", erro);
  });

Tratamento de Erros

O tratamento de erros com Promises é feito através do método catch(). Quando uma Promise é rejeitada (ou seja, ocorre um erro), o catch() é acionado, permitindo que lidemos com o erro de forma controlada.

Exemplo de tratamento de erros com Promises:
function carregarDados(url) {
  return new Promise(function(resolve, reject) {
    // Simula uma requisição de rede com erro
    setTimeout(function() {
      const erro = "Erro ao carregar os dados";
      reject(erro); // Promise é rejeitada com erro
    }, 2000); // Espera 2 segundos antes de rejeitar a Promise
  });
}

carregarDados("https://exemplo.com/dados")
  .then(function(dados) {
    console.log("Dados carregados:", dados);
  })
  .catch(function(erro) {
    console.error(erro);
  });

Tratamento de Erros em Encadeamento

Ao encadear várias Promises, podemos utilizar o catch() em cada uma delas para tratar possíveis erros que ocorram em qualquer etapa do encadeamento.

Exemplo de tratamento de erros em encadeamento:
function carregarDados(url) {
  return new Promise(function(resolve, reject) {
    // Simula uma requisição de rede com erro
    setTimeout(function() {
      const erro = "Erro ao carregar os dados";
      reject(erro); // Promise é rejeitada com erro
    }, 2000); // Espera 2 segundos antes de rejeitar a Promise
  });
}

function processarDados(dados) {
  return new Promise(function(resolve) {
    // Simula processamento de dados com erro
    setTimeout(function() {
      const erro = "Erro ao processar os dados";
      reject(erro); // Promise é rejeitada com erro
    }, 1000); // Espera 1 segundo antes de rejeitar a Promise
  });
}

carregarDados("https://exemplo.com/dados")
  .then(processarDados)
  .catch(function(erro) {
    console.error(erro);
  });

O encadeamento de Promises e o tratamento de erros são técnicas essenciais para lidar com operações assíncronas em JavaScript de forma mais elegante e organizada. O encadeamento permite uma sequência de operações sem aninhamento excessivo de callbacks, tornando o código mais legível, enquanto o tratamento de erros nos ajuda a lidar com possíveis falhas nas operações assíncronas de forma controlada. Continue praticando e aprimorando suas habilidades com Promises para criar códigos mais eficientes e confiáveis em suas aplicações web com JavaScript.

Dúvidas?