0Pricing
jQuery Academy · Aula

Tratamento de Erros e Sucessos em AJAX

Implemente mecanismos robustos de tratamento de erros com os retornos de chamada .fail() e .always() e processe a recuperação bem-sucedida de dados com .done() para aplicações resilientes.

Tratamento de Erros e Sucessos em AJAX é uma aula grátis de jQuery Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de jQuery Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de jQuery Academy inclui 3 aulas no total.

Lidando com resultados assíncronos

Quando faz uma solicitação AJAX, trata-se de uma operação assíncrona. Isso significa que o seu código não espera a resposta do servidor; ele continua executando outras tarefas.

Para lidar com a resposta do servidor (ou com a ausência dela), o jQuery fornece métodos especiais chamados funções de retorno. Essas funções são executadas somente quando determinados eventos ocorrem, como sucesso ou falha.

Quando tudo dá certo

A função de retorno .done() é a opção principal para lidar com solicitações AJAX bem-sucedidas. Ela é executada quando o servidor responde com um código de status que indica sucesso (normalmente entre 200 e 299).

  • Ela recebe os dados retornados pelo servidor.
  • É o lugar ideal para atualizar a interface do usuário com informações recentes.

Exibindo dados obtidos com sucesso

Vamos buscar alguns dados e exibi-los quando a solicitação for bem-sucedida. Observe como .done() é encadeada à chamada $.ajax().

$(document).ready(function() {
  $.ajax({
    url: "https://jsonplaceholder.typicode.com/posts/1",
    method: "GET"
  })
  .done(function(data) {
    console.log("Success! Data received:");
    console.log(data.title); // Access a property
    $('body').append('<p>Post Title: ' + data.title + '</p>');
  });
});

Quando algo dá errado

Mas e se o servidor não puder atender à sua solicitação? É nesse caso que entra a função de retorno .fail(). Ela é executada quando a solicitação AJAX encontra um erro, como um 404 (Não encontrado) ou 500 (Erro do servidor).

  • Ela ajuda você a informar o usuário ou registrar problemas.
  • Ela recebe detalhes sobre o erro.

Respondendo a falhas

Vamos tentar buscar dados de uma URL inexistente. A função de retorno .fail() capturará o erro e registrará os detalhes.

$(document).ready(function() {
  $.ajax({
    url: "https://jsonplaceholder.typicode.com/nonexistent", // This URL will fail
    method: "GET"
  })
  .done(function(data) {
    console.log("This won't run on error.");
  })
  .fail(function(jqXHR, textStatus, errorThrown) {
    console.log("Error! Status: " + textStatus);
    console.log("HTTP Error: " + errorThrown);
    $('body').append('<p>Error fetching data!</p>');
    $('body').append('<p>Status: ' + textStatus + '</p>');
  });
});

Decodificando os parâmetros de erro

A função de retorno .fail() fornece três parâmetros úteis para ajudar você a entender o que deu errado:

  • jqXHR: o objeto XMLHttpRequest do jQuery, que oferece detalhes de baixo nível.
  • textStatus: uma cadeia de caracteres que descreve o tipo de erro (por exemplo, "timeout", "error", "abort").
  • errorThrown: o texto do status HTTP (por exemplo, "Not Found" para um 404).

Use esses parâmetros para fornecer informações específicas aos usuários.

Sempre em execução, aconteça o que acontecer

Às vezes, você precisa executar uma ação independentemente de a solicitação AJAX ter sido bem-sucedida ou ter falhado. Essa é a função da função de retorno .always().

  • Ela é sempre executada depois de qualquer uma das duas, .done() ou .fail().
  • É ótima para tarefas de limpeza, como ocultar um indicador de carregamento ou reativar um botão.

Executando a limpeza

Vamos adicionar .always() ao exemplo anterior. Simularemos um estado de carregamento e garantiremos que ele seja removido independentemente de a solicitação ser bem-sucedida ou falhar.

$(document).ready(function() {
  $('body').append('<p id="status">Loading data...</p>'); // Simulate loading
  $.ajax({
    url: "https://jsonplaceholder.typicode.com/posts/1", // Try changing to 'nonexistent' to see fail+always
    method: "GET"
  })
  .done(function(data) {
    console.log("Success! Data: " + data.title);
    $('#status').text('Data loaded successfully!');
  })
  .fail(function(jqXHR, textStatus, errorThrown) {
    console.log("Failed! " + textStatus);
    $('#status').text('Failed to load data!');
  })
  .always(function() {
    console.log("Request finished (success or failure).");
    // This could be where you hide a spinner or re-enable a button
    $('#status').append(' (Finished)');
  });
});

Organizando suas funções de retorno

Os métodos AJAX do jQuery retornam um objeto semelhante a uma Promise, permitindo encadear diretamente os métodos .done(), .fail() e .always().

Esse encadeamento torna o código mais limpo e fácil de ler, separando claramente os blocos de lógica de sucesso, erro e finalização.

Teste seus conhecimentos

Considere a seguinte solicitação AJAX do jQuery:


$.ajax({
  url: "/api/data",
  method: "GET"
})
.done(function() {
  console.log("A");
})
.fail(function() {
  console.log("B");
})
.always(function() {
  console.log("C");
});

Se o servidor responder com um erro 404 Not Found, o que será exibido no console?

Resumo do tratamento de AJAX

Você aprendeu as funções de retorno essenciais para um tratamento robusto de AJAX:

  • .done(): para respostas bem-sucedidas.
  • .fail(): para lidar com erros.
  • .always(): para ações que devem ser executadas aconteça o que acontecer.

Ao usá-las, seus aplicativos podem lidar de forma adequada com as interações de rede, proporcionando uma experiência melhor aos usuários mesmo quando as coisas não saem como planejado!

Perguntas Frequentes

A aula “Tratamento de Erros e Sucessos em AJAX” é grátis?

Sim — o texto completo de “Tratamento de Erros e Sucessos em AJAX” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de jQuery Academy, atualize para CoddyKit PRO. O curso de jQuery Academy inclui 3 aulas no total.

O que vou aprender em “Tratamento de Erros e Sucessos em AJAX”?

Implemente mecanismos robustos de tratamento de erros com os retornos de chamada .fail() e .always() e processe a recuperação bem-sucedida de dados com .done() para aplicações resilientes. Você pratica jQuery Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar jQuery Academy?

Nenhuma experiência prévia é necessária. jQuery Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Tratamento de Erros e Sucessos em AJAX”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de jQuery Academy?

Sim. Cada aula de jQuery Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Configuração Eficiente de Solicitações AJAX
  2. Tratamento de Erros e Sucessos em AJAX
  3. AJAX entre Domínios (CORS/JSONP)
← Voltar para jQuery Academy