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
- Configuração Eficiente de Solicitações AJAX
- Tratamento de Erros e Sucessos em AJAX
- AJAX entre Domínios (CORS/JSONP)