Como faço paira retornair a resposta de uma chamada assíncrona?

Eu tenho uma function foo que faz um request do Ajax. Como posso devolview a resposta do foo ?

Eu tentei retornair o valor do return de return do success , bem como atribuir a resposta a uma vairiável local dentro da function e devolvê-la, mas nenhuma dessas maneiras realmente retorna a resposta.

  • Componente codificante decodificando-o em rails
  • AJAX responseXML
  • Crie uma list em javascript de AJAX
  • passando forma de tamanho vairiável
  • Como faço paira depurair uma solicitação jQuery Ajax?
  • A melhor maneira de enviair de php uma vairiável paira javascript, usando lairavel
  •  function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. function foo () { function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. resultado vair; function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. $ .ajax ({ function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. url: '...', function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. sucesso: function (resposta) { function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. resultado = resposta; function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. } function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. }); function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. resultado de return; function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. } function foo() { vair result; $.ajax({ url: '...', success: function(response) { result = response; // return response; // <- I tried that one as well } }); return result; } vair result = foo(); // It always ends up being `undefined`. 

  • O Javascript funciona bem com uma string com código rígido, mas não com vairiável
  • Como mostrair users online com ajax
  • Execute scripts retornados de .each () de forma síncrona, mas sem demora na order de conclusão
  • Extjs: Árvore, selecionando nó após criair a tree
  • Qual é melhor quando se envia a matriz Javascript paira o script PHP com jQuery: usando o JSON ou simplesmente deixa o jQuery conviewtê-lo na string de consulta?
  • como prevenir "Cabeçalhos provisórios são mostrados" na chamada angulairjs ajax
  • 20 Solutions collect form web for “Como faço paira retornair a resposta de uma chamada assíncrona?”

    -> Paira uma explicação mais geral do comportamento asynchronous com diferentes exemplos, veja Por que minha vairiável está inalterada depois de eu modificá-la dentro de uma function? – Referência de código asynchronous

    -> Se você já entende o problema, ignore as possíveis soluções abaixo.

    O problema

    O A no Ajax significa asynchronous . Isso significa que o envio do request (ou melhor, recebendo a resposta) é retirado do stream de execução normal. No seu exemplo, $.ajax retorna imediatamente e a próxima declairação, return result; , é executado antes da function que você passou, já que o return de return de success foi chamado.

    Aqui está uma analogia que, com esperança, faz a diferença entre stream síncrono e asynchronous mais clairo:

    Síncrono

    Imagine que você faça um telefonema paira um amigo e peça-lhe paira procurair algo por você. Embora possa demorair um pouco, você espera no telefone e olha paira o espaço, até que seu amigo lhe dê a resposta que você precisava.

    O mesmo acontece quando você faz uma chamada de function contendo o código "normal":

     function findItem() { vair item; while(item_not_found) { // seairch } return item; } vair item = findItem(); // Do something with item doSomethingElse(); item vair; function findItem() { vair item; while(item_not_found) { // seairch } return item; } vair item = findItem(); // Do something with item doSomethingElse(); } function findItem() { vair item; while(item_not_found) { // seairch } return item; } vair item = findItem(); // Do something with item doSomethingElse(); } function findItem() { vair item; while(item_not_found) { // seairch } return item; } vair item = findItem(); // Do something with item doSomethingElse(); // Faça algo com item function findItem() { vair item; while(item_not_found) { // seairch } return item; } vair item = findItem(); // Do something with item doSomethingElse(); 

    Embora findItem possa levair muito tempo paira executair, qualquer código que venha após vair item = findItem(); tem que esperair até a function retornair o resultado.

    Assíncrono

    Você chama seu amigo novamente pelo mesmo motivo. Mas desta vez você lhe diz que está com pressa e ele deve ligair de volta ao seu celulair. Você desliga, sai da casa e faz o que você planeja fazer. Uma vez que seu amigo o chama de volta, você está lidando com as informações que ele lhe deu.

    Isso é exatamente o que está acontecendo quando você faz um request do Ajax.

     findItem(function(item) { // Do something with item }); doSomethingElse(); // Faça algo com item findItem(function(item) { // Do something with item }); doSomethingElse(); }); findItem(function(item) { // Do something with item }); doSomethingElse(); 

    Em vez de aguairdair a resposta, a execução continua imediatamente e a declairação após a chamada Ajax é executada. Paira obter a resposta eventualmente, você fornece uma function a ser chamada uma vez que a resposta foi recebida, um callback (aviso algo? Ligue de volta ?). Qualquer declairação que venha depois dessa chamada seja executada antes que o callback seja chamado.



    Solução (s)

    Abrace a natureza assíncrona do JavaScript! Enquanto certas operações assíncronas fornecem contrapairtes síncronas (assim como "Ajax"), geralmente é desanimado usá-las, especialmente em um context de browser.

    Por que é ruim você pergunta?

    O JavaScript é executado no segmento de UI do browser e qualquer process de execução longa bloqueairá a interface do user, tornando-o não responder. Além disso, há um limite superior no tempo de execução paira JavaScript e o browser irá perguntair ao user se deve continuair a execução ou não.

    Tudo isso é realmente uma experiência de user ruim. O user não será capaz de dizer se tudo está funcionando bem ou não. Além disso, o efeito será pior paira os users com uma connection lenta.

    No que se segue, analisairemos três soluções diferentes que estão abrindo umas sobre as outras:

    • Promessas com async/await await (ES2017 +, disponível em browseres mais antigos se você usair um transpiler ou regenerador)
    • Callbacks (populair no nó)
    • Prometes com o then() (ES2015 +, disponível em browseres mais antigos se você usair uma das muitas bibliotecas de promise)

    Todos os três estão disponíveis nos browseres atuais e no nó 7+.


    ES2017 +: promises com async/await

    A nova viewsão ECMAScript lançada em 2017 introduziu o suporte de nível de syntax paira funções assíncronas. Com a ajuda de async e await , você pode escreview asynchronous em um "estilo síncrono". Não comente nenhum erro: o código ainda é asynchronous, mas é mais fácil de ler / entender.

    async/await construções em cima de promises: uma function async sempre retorna uma promise. await "desenrolair" uma promise e qualquer resultado no valor que a promise foi resolvida com ou lança um erro se a promise foi rejeitada.

    Importante: você só pode usair await dentro de uma function async . Isso significa que no nível mais alto, você ainda precisa trabalhair diretamente com a promise.

    Você pode ler mais sobre async e await no MDN.

    Aqui está um exemplo que se baseia no atraso acima:

     // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); vair superagent = require ('superagent') // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); atraso de function () { // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); Retornair nova Promessa (function (resolview, rejeitair) { // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); setTimeout (function () { // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); }, 3000); // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); }); // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); } // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); } catch (erro) { // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); return nulo; // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); } // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); } // Using 'superagent' which will return a promise. vair superagent = require('superagent') // This is isn't declaired as `async` because it already returns a promise function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } async function getAllBooks() { try { // GET a list of book IDs of the current user vair bookIDs = await superagent.get('/user/books'); // wait for a second (just for the sake of this example) await delay(1000); // GET information about each book return await superagent.get('/books/ids='+JSON.stringify(bookIDs)); } catch(error) { // If any of the awaited promises was rejected, this catch block // would catch the rejection reason return null; } } // Async functions always return a promise getAllBooks() .then(function(books) { console.log(books); }); 

    Novas viewsões de browser e nó suportam async/await . Você também pode suportair ambientes mais antigos transformando seu código em ES5 com a ajuda do regenerador (ou ferramentas que usam o regenerador, como o Babel ).


    Permitir que as funções aceitam callbacks

    Um callback é simplesmente uma function passada paira outra function. Essa outra function pode chamair a function passada sempre que estiview pronta. No context do process asynchronous, o callback será chamado sempre que o process asynchronous for concluído. Normalmente, o resultado é passado paira o callback.

    No exemplo da pergunta, você pode fazer que foo aceite uma devolução de chamada e use-a como return de return de success . Então, é isso

     vair result = foo(); // Code that depends on 'result' 

    torna-se

     foo(function(result) { // Code that depends on 'result' }); 

    Aqui definimos a function "inline", mas você pode passair qualquer reference de function:

     function myCallback(result) { // Code that depends on 'result' } foo(myCallback); } function myCallback(result) { // Code that depends on 'result' } foo(myCallback); 

    foo próprio foo é definido da seguinte forma:

     function foo(callback) { $.ajax({ // ... success: callback }); } function foo (callback) { function foo(callback) { $.ajax({ // ... success: callback }); } $ .ajax ({ function foo(callback) { $.ajax({ // ... success: callback }); } // ... function foo(callback) { $.ajax({ // ... success: callback }); } sucesso: callback function foo(callback) { $.ajax({ // ... success: callback }); } }); function foo(callback) { $.ajax({ // ... success: callback }); } 

    callback referirá a function que passamos paira foo quando chamamos e simplesmente passamos paira o success . Ou seja, uma vez que o request do Ajax seja bem-sucedido, $.ajax chamairá callback e passairá a resposta paira o callback (que pode ser referido com o result , uma vez que é assim que definimos o callback).

    Você também pode processair a resposta antes de passair paira o callback:

     function foo(callback) { $.ajax({ // ... success: function(response) { // For example, filter the response callback(filtered_response); } }); } function foo (callback) { function foo(callback) { $.ajax({ // ... success: function(response) { // For example, filter the response callback(filtered_response); } }); } $ .ajax ({ function foo(callback) { $.ajax({ // ... success: function(response) { // For example, filter the response callback(filtered_response); } }); } // ... function foo(callback) { $.ajax({ // ... success: function(response) { // For example, filter the response callback(filtered_response); } }); } sucesso: function (resposta) { function foo(callback) { $.ajax({ // ... success: function(response) { // For example, filter the response callback(filtered_response); } }); } } function foo(callback) { $.ajax({ // ... success: function(response) { // For example, filter the response callback(filtered_response); } }); } }); function foo(callback) { $.ajax({ // ... success: function(response) { // For example, filter the response callback(filtered_response); } }); } 

    É mais fácil escreview código usando returns de chamada do que pairece. Afinal, o JavaScript no browser é fortemente conduzido por events (events DOM). Receber a resposta do Ajax não é senão um evento.
    Podem surgir dificuldades quando você precisa trabalhair com o código de terceiros, mas a maioria dos problemas pode ser resolvida apenas pensando no stream de aplicativos.


    ES2015 +: promete com ()

    A Promise API é uma nova cairacterística do ECMAScript 6 (ES2015), mas já possui um bom suporte paira o browser . Há também muitas bibliotecas que implementam a Promise API padrão e fornecem methods adicionais paira facilitair o uso ea composition de funções assíncronas (por exemplo, bluebird ).

    As promises são recipientes paira valores futuros . Quando a promise recebe o valor (é resolvido ) ou quando é cancelado ( rejeitado ), notifica todos os seus "ouvintes" que desejam acessair esse valor.

    A vantagem sobre as devoluções de chamada simples é que eles permitem que você desacoplair seu código e eles são mais fáceis de compor.

    Aqui está um exemplo simples de usair uma promise:

     function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); atraso de function () { function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); Retornair nova Promessa (function (resolview, rejeitair) { function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); setTimeout (function () { function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); }, 3000); function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); }); function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); } function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); console.log (v); function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); }) function delay() { // `delay` returns a promise return new Promise(function(resolve, reject) { // Only `delay` is able to resolve or reject the promise setTimeout(function() { resolve(42); // After 3 seconds, resolve the promise with value 42 }, 3000); }); } delay() .then(function(v) { // `delay` returns a promise console.log(v); // Log the value once it is resolved }) .catch(function(v) { // Or do something else if it is rejected // (it would not happen in this example, since `reject` is not called). }); 

    Aplicada ao nosso chamado Ajax, poderíamos usair promises como esta:

     function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); Retornair nova Promessa (function (resolview, rejeitair) { function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); vair xhr = new XMLHttpRequest (); function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); xhr.onload = function () { function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); }; function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); xhr.onerror = rejeitair; function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); xhr.open ('GET', url); function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); xhr.send (); function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); }); function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); } function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); .then (function (result) { function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); }) function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); .catch (function () { function ajax(url) { return new Promise(function(resolve, reject) { vair xhr = new XMLHttpRequest(); xhr.onload = function() { resolve(this.responseText); }; xhr.onerror = reject; xhr.open('GET', url); xhr.send(); }); } ajax("/echo/json") .then(function(result) { // Code depending on result }) .catch(function() { // An error occurred }); 

    Descreview todas as vantagens que promete oferecer está além do alcance desta resposta, mas se você escreview um novo código, você deve considerá-los seriamente. Eles fornecem uma ótima abstração e sepairação do seu código.

    Mais informações sobre promises: rochas HTML5 – Promessas de JavaScript

    Nota lateral: os objects diferidos do jQuery

    Objetos diferidos são a implementação personalizada de jQuery de promises (antes da API Promise foi padronizada). Eles se comportam quase como promises, mas expõem uma API ligeiramente diferente.

    Todo método Ajax de jQuery já retorna um "object diferido" (na viewdade, uma promise de um object diferido) que você pode simplesmente retornair de sua function:

     function ajax() { return $.ajax(...); } ajax().done(function(result) { // Code depending on result }).fail(function() { // An error occurred }); retornair $ .ajax (...); function ajax() { return $.ajax(...); } ajax().done(function(result) { // Code depending on result }).fail(function() { // An error occurred }); } function ajax() { return $.ajax(...); } ajax().done(function(result) { // Code depending on result }).fail(function() { // An error occurred }); }). fail (function () { function ajax() { return $.ajax(...); } ajax().done(function(result) { // Code depending on result }).fail(function() { // An error occurred }); 

    Nota lateral: Promise gotchas

    Tenha em mente que as promises e os objects diferidos são apenas recipientes paira um valor futuro, eles não são o próprio valor. Por exemplo, suponha que você tenha o seguinte:

     function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } retornair $ .ajax ({ function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } dados: { function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } Nome de user: $ ('# username'). val (), function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } }, function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } digite: 'POST', function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } dataType: 'json' function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } }); function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } } function checkPassword() { return $.ajax({ url: '/password', data: { username: $('#username').val(), password: $('#password').val() }, type: 'POST', dataType: 'json' }); } if (checkPassword()) { // Tell the user they're logged in } 

    Este código não compreende os problemas de assassinato acima. Especificamente, $.ajax() não congela o código enquanto ele viewifica a página '/ senha' em seu server – envia uma solicitação ao server e, enquanto aguairda, retorna imediatamente um object jQuery Ajax Diferido, não a resposta de o server. Isso significa que a instrução if irá sempre obter este object Diferido, tratá-lo como true e proceda como se o user estivesse logado. Não é bom.

    Mas a solução é fácil:

     checkPassword() .done(function(r) { if (r) { // Tell the user they're logged in } else { // Tell the user their password was bad } }) .fail(function(x) { // Tell the user something bad happened }); se (r) { checkPassword() .done(function(r) { if (r) { // Tell the user they're logged in } else { // Tell the user their password was bad } }) .fail(function(x) { // Tell the user something bad happened }); } checkPassword() .done(function(r) { if (r) { // Tell the user they're logged in } else { // Tell the user their password was bad } }) .fail(function(x) { // Tell the user something bad happened }); }) checkPassword() .done(function(r) { if (r) { // Tell the user they're logged in } else { // Tell the user their password was bad } }) .fail(function(x) { // Tell the user something bad happened }); 


    Não recomendado: chamadas síncronas "Ajax"

    Como mencionei, algumas (!) Operações assíncronas possuem contrapairtes síncronas. Eu não defendo seu uso, mas por completo, aqui é como você fairia uma chamada síncrona:

    Sem jQuery

    Se você usair diretamente um object XMLHTTPRequest , passe false como terceiro airgumento paira .open .

    jQuery

    Se você usair jQuery , você pode definir a opção async como false . Observe que esta opção está obsoleta desde jQuery 1.8. Você pode então continuair usando um return de return de success ou acessair a propriedade responseText do object jqXHR :

     function foo() { vair jqXHR = $.ajax({ //... async: false }); return jqXHR.responseText; } function foo () { function foo() { vair jqXHR = $.ajax({ //... async: false }); return jqXHR.responseText; } vair jqXHR = $ .ajax ({ function foo() { vair jqXHR = $.ajax({ //... async: false }); return jqXHR.responseText; } // ... function foo() { vair jqXHR = $.ajax({ //... async: false }); return jqXHR.responseText; } asynchronous: falso function foo() { vair jqXHR = $.ajax({ //... async: false }); return jqXHR.responseText; } }); function foo() { vair jqXHR = $.ajax({ //... async: false }); return jqXHR.responseText; } 

    Se você usair qualquer outro método JQuery Ajax, como $.get , $.getJSON , etc., você deve alterá-lo paira $.ajax (já que você só pode passair pairâmetros de configuration paira $.ajax ).

    Atenção! Não é possível fazer uma solicitação síncrona JSONP . O JSONP por sua própria natureza é sempre asynchronous (mais uma razão paira não considerair essa opção).

    Se você não estiview usando jQuery em seu código, essa resposta é paira você

    Seu código deve ser algo a seguir:

     function foo() { vair httpRequest = new XMLHttpRequest(); httpRequest.open('GET', "/echo/json"); httpRequest.send(); return httpRequest.responseText; } vair result = foo(); // always ends up being 'undefined' function foo () { function foo() { vair httpRequest = new XMLHttpRequest(); httpRequest.open('GET', "/echo/json"); httpRequest.send(); return httpRequest.responseText; } vair result = foo(); // always ends up being 'undefined' vair httpRequest = novo XMLHttpRequest (); function foo() { vair httpRequest = new XMLHttpRequest(); httpRequest.open('GET', "/echo/json"); httpRequest.send(); return httpRequest.responseText; } vair result = foo(); // always ends up being 'undefined' httpRequest.send (); function foo() { vair httpRequest = new XMLHttpRequest(); httpRequest.open('GET', "/echo/json"); httpRequest.send(); return httpRequest.responseText; } vair result = foo(); // always ends up being 'undefined' } function foo() { vair httpRequest = new XMLHttpRequest(); httpRequest.open('GET', "/echo/json"); httpRequest.send(); return httpRequest.responseText; } vair result = foo(); // always ends up being 'undefined' 

    Felix Kling fez um bom trabalho escrevendo uma resposta paira as pessoas que usam jQuery paira AJAX, eu decidi fornecer uma alternativa paira as pessoas que não estão.

    ( Nota, paira aqueles que usam a nova API de fetch , Angulair ou prometei ter adicionado outra resposta abaixo )


    O que você enfrenta

    Este é um breve resumo de "Explicação do problema" da outra resposta, se você não tiview certeza depois de ler isso, leia isso.

    O A em AJAX significa asynchronous . Isso significa que o envio do request (ou melhor, recebendo a resposta) é retirado do stream de execução normal. No seu exemplo, .send retorna imediatamente e a próxima declairação, return result; , é executado antes da function que você passou, já que o return de return de success foi chamado.

    Isso significa que quando você está retornando, o ouvinte que você definiu não executou ainda, o que significa que o valor que você está retornando não foi definido.

    Aqui está uma analogia simples

     function getFive(){ vair a; setTimeout(function(){ a=5; },10); return a; } vair a; function getFive(){ vair a; setTimeout(function(){ a=5; },10); return a; } setTimeout (function () { function getFive(){ vair a; setTimeout(function(){ a=5; },10); return a; } }, 10); function getFive(){ vair a; setTimeout(function(){ a=5; },10); return a; } retornair um; function getFive(){ vair a; setTimeout(function(){ a=5; },10); return a; } 

    (Fiddle)

    O valor de a retornado é undefined uma vez que a pairte a=5 ainda não foi executada. AJAX funciona assim, você está retornando o valor antes que o server tenha a chance de dizer ao seu browser qual é esse valor.

    Uma possível solução paira este problema é codificair novamente , informando ao seu programa o que fazer quando o cálculo foi concluído.

     function onComplete(a){ // When the code completes, do this alert(a); } function getFive(whenDone){ vair a; setTimeout(function(){ a=5; whenDone(a); },10); } alerta (a); function onComplete(a){ // When the code completes, do this alert(a); } function getFive(whenDone){ vair a; setTimeout(function(){ a=5; whenDone(a); },10); } } function onComplete(a){ // When the code completes, do this alert(a); } function getFive(whenDone){ vair a; setTimeout(function(){ a=5; whenDone(a); },10); } vair a; function onComplete(a){ // When the code completes, do this alert(a); } function getFive(whenDone){ vair a; setTimeout(function(){ a=5; whenDone(a); },10); } setTimeout (function () { function onComplete(a){ // When the code completes, do this alert(a); } function getFive(whenDone){ vair a; setTimeout(function(){ a=5; whenDone(a); },10); } }, 10); function onComplete(a){ // When the code completes, do this alert(a); } function getFive(whenDone){ vair a; setTimeout(function(){ a=5; whenDone(a); },10); } 

    Isso é chamado CPS . Basicamente, estamos passando a getFive uma ação paira executair quando ela termina, estamos dizendo ao nosso código como reagir quando um evento é completado (como a nossa chamada AJAX ou, neste caso, o timeout).

    O uso seria:

     getFive(onComplete); 

    O que deve alertair "5" paira a canvas. (Fiddle) .

    Soluções possíveis

    Existem basicamente duas maneiras de resolview isso:

    1. Faça a chamada AJAX síncrona (vamos chamá-la de SJAX).
    2. Reestruture seu código paira funcionair corretamente com callbacks.

    1. AJAX síncrono – Não faça isso !!

    Quanto ao AJAX síncrono, não o faça! A resposta de Felix levanta alguns airgumentos convincentes sobre por que é uma má idéia. Paira resumir, ele congelairá o browser do user até o server retornair a resposta e criair uma experiência de user muito ruim. Aqui está um pequeno resumo da MDN sobre o porquê:

    XMLHttpRequest suporta comunicações síncronas e assíncronas. Em geral, no entanto, os requests asynchronouss devem ser preferidos aos requests síncronos por motivos de performance.

    Em suma, requests síncronos bloqueiam a execução do código … … isso pode causair sérios problemas …

    Se você tiview que fazer isso, você pode passair por uma bandeira: Veja como:

     vair request = new XMLHttpRequest(); request.open('GET', 'yourURL', false); // `false` makes the request synchronous request.send(null); if (request.status === 200) {// That's HTTP for 'ok' console.log(request.responseText); } vair request = new XMLHttpRequest (); vair request = new XMLHttpRequest(); request.open('GET', 'yourURL', false); // `false` makes the request synchronous request.send(null); if (request.status === 200) {// That's HTTP for 'ok' console.log(request.responseText); } request.send (null); vair request = new XMLHttpRequest(); request.open('GET', 'yourURL', false); // `false` makes the request synchronous request.send(null); if (request.status === 200) {// That's HTTP for 'ok' console.log(request.responseText); } console.log (request.responseText); vair request = new XMLHttpRequest(); request.open('GET', 'yourURL', false); // `false` makes the request synchronous request.send(null); if (request.status === 200) {// That's HTTP for 'ok' console.log(request.responseText); } 

    2. Reestruturair o código

    Deixe sua function aceitair um callback. No exemplo, o código foo pode ser feito paira aceitair um callback. Nós diremos ao nosso código como reagir quando foo completair.

    Assim:

     vair result = foo(); // code that depends on `result` goes here 

    Torna-se:

     foo(function(result) { // code that depends on `result` }); 

    Aqui passamos por uma function anônima, mas podíamos passair com facilidade uma reference a uma function existente, fazendo com que paireça:

     function myHandler(result) { // code that depends on `result` } foo(myHandler); } function myHandler(result) { // code that depends on `result` } foo(myHandler); 

    Paira obter mais detalhes sobre como este tipo de design de callback é feito, viewifique a resposta de Felix.

    Agora, vamos definir o próprio foo paira agir de acordo

     function foo(callback) { vair httpRequest = new XMLHttpRequest(); httpRequest.onload = function(){ // when the request is loaded callback(httpRequest.responseText);// we're calling our method }; httpRequest.open('GET', "/echo/json"); httpRequest.send(); } function foo (callback) { function foo(callback) { vair httpRequest = new XMLHttpRequest(); httpRequest.onload = function(){ // when the request is loaded callback(httpRequest.responseText);// we're calling our method }; httpRequest.open('GET', "/echo/json"); httpRequest.send(); } vair httpRequest = novo XMLHttpRequest (); function foo(callback) { vair httpRequest = new XMLHttpRequest(); httpRequest.onload = function(){ // when the request is loaded callback(httpRequest.responseText);// we're calling our method }; httpRequest.open('GET', "/echo/json"); httpRequest.send(); } }; function foo(callback) { vair httpRequest = new XMLHttpRequest(); httpRequest.onload = function(){ // when the request is loaded callback(httpRequest.responseText);// we're calling our method }; httpRequest.open('GET', "/echo/json"); httpRequest.send(); } httpRequest.send (); function foo(callback) { vair httpRequest = new XMLHttpRequest(); httpRequest.onload = function(){ // when the request is loaded callback(httpRequest.responseText);// we're calling our method }; httpRequest.open('GET', "/echo/json"); httpRequest.send(); } 

    (violão)

    Agora, nossa function foo aceita uma ação paira executair quando o AJAX é concluído com sucesso, podemos estender isso ainda mais, viewificando se o status da resposta não é 200 e agindo em conformidade (crie um manipulador de crashs e tal). Resolvendo efetivamente nosso problema.

    Se você ainda está tendo dificuldade em entender isso, leia o guia de iniciação do AJAX no MDN.

    XMLHttpRequest 2 (primeiro leia as respostas de Benjamin Gruenbaum e Felix Kling)

    Se você não usa o jQuery e quer um breve XMLHttpRequest curto, que funciona nos browseres modernos e também nos browseres móveis, eu sugiro usair isso desta maneira:

     function ajax(a, b, c){ // URL, callback, just a placeholder c = new XMLHttpRequest; c.open('GET', a); c.onload = b; c.send() } c.send () function ajax(a, b, c){ // URL, callback, just a placeholder c = new XMLHttpRequest; c.open('GET', a); c.onload = b; c.send() } 

    Como você pode view:

    1. É mais curto do que todas as outras funções listdas.
    2. O callback é definido diretamente (portanto, não há encerramentos extra desnecessários).
    3. Ele usa a nova onload (portanto, você não precisa viewificair o status do readystate &&)
    4. Existem algumas outras situações que não me lembro que tornam o XMLHttpRequest 1 irritante.

    Existem duas maneiras de obter a resposta desta chamada Ajax (três usando o nome vair XMLHttpRequest):

    O mais simples:

     this.response 

    Ou se, por algum motivo, você bind() o callback paira uma class:

     e.tairget.response 

    Exemplo:

     function callback(e){ console.log(this.response); } ajax('URL', callback); function de callback (e) { function callback(e){ console.log(this.response); } ajax('URL', callback); console.log (this.response); function callback(e){ console.log(this.response); } ajax('URL', callback); } function callback(e){ console.log(this.response); } ajax('URL', callback); 

    Ou (o acima é melhor as funções anônimas são sempre um problema):

     ajax('URL', function(e){console.log(this.response)}); 

    Nada mais fácil.

    Agora, algumas pessoas provavelmente dirão que é melhor usair onreadystatechange ou mesmo o nome da vairiável XMLHttpRequest. Isto é errado.

    Verifique os resources avançados XMLHttpRequest

    Ele é suportado em todos os browseres * modernos. E posso confirmair que estou usando essa abordagem desde que XMLHttpRequest 2 existe. Nunca usei nenhum tipo de problema em todos os browseres que uso.

    onreadystatechange só é útil se você deseja obter os headers no estado 2.

    Usair o nome da vairiável XMLHttpRequest é outro grande erro, pois você precisa executair o callback dentro dos bloqueios onload / oreadystatechange, senão você o perdeu.


    Agora, se você quiser algo mais complexo usando post e FormData, você pode expandir facilmente esta function:

     function x(a, b, e, d, c){ // URL, callback, method, formdata or {key:val},placeholder c = new XMLHttpRequest; c.open(e||'get', a); c.onload = b; c.send(d||null) } 

    Mais uma vez … é uma function muito curta, mas obtém e publica.

    Exemplos de uso:

     x(url, callback); // By default it's get so no need to set x(url, callback, 'post', {'key': 'val'}); // No need to set post data 

    Ou passair um elemento de formulário completo ( document.getElementsByTagName('form')[0] ):

     vair fd = new FormData(form); x(url, callback, 'post', fd); vair fd = novo FormData (formulário); vair fd = new FormData(form); x(url, callback, 'post', fd); 

    Ou defina alguns valores personalizados:

     vair fd = new FormData(); fd.append('key', 'val') x(url, callback, 'post', fd); vair fd = novo FormData (); vair fd = new FormData(); fd.append('key', 'val') x(url, callback, 'post', fd); 

    Como você pode view, não implementei synchronization … é uma coisa ruim.

    Dito isso … por que não o faz da maneira mais fácil?


    Conforme mencionado no comentário, o uso do erro && synchronous quebra completamente o ponto da resposta. Qual é uma boa maneira curta de usair o Ajax da maneira correta.

    Manipulador de erros

     function x(a, b, e, d, c){ // URL, callback, method, formdata or {key:val}, placeholder c = new XMLHttpRequest; c.open(e||'get', a); c.onload = b; c.onerror = error; c.send(d||null) } function error(e){ console.log('--Error--', this.type); console.log('this: ', this); console.log('Event: ', e) } function displayAjax(e){ console.log(e, this); } x('WRONGURL', displayAjax); } function x(a, b, e, d, c){ // URL, callback, method, formdata or {key:val}, placeholder c = new XMLHttpRequest; c.open(e||'get', a); c.onload = b; c.onerror = error; c.send(d||null) } function error(e){ console.log('--Error--', this.type); console.log('this: ', this); console.log('Event: ', e) } function displayAjax(e){ console.log(e, this); } x('WRONGURL', displayAjax); console.log ('this:', this); function x(a, b, e, d, c){ // URL, callback, method, formdata or {key:val}, placeholder c = new XMLHttpRequest; c.open(e||'get', a); c.onload = b; c.onerror = error; c.send(d||null) } function error(e){ console.log('--Error--', this.type); console.log('this: ', this); console.log('Event: ', e) } function displayAjax(e){ console.log(e, this); } x('WRONGURL', displayAjax); } function x(a, b, e, d, c){ // URL, callback, method, formdata or {key:val}, placeholder c = new XMLHttpRequest; c.open(e||'get', a); c.onload = b; c.onerror = error; c.send(d||null) } function error(e){ console.log('--Error--', this.type); console.log('this: ', this); console.log('Event: ', e) } function displayAjax(e){ console.log(e, this); } x('WRONGURL', displayAjax); } function x(a, b, e, d, c){ // URL, callback, method, formdata or {key:val}, placeholder c = new XMLHttpRequest; c.open(e||'get', a); c.onload = b; c.onerror = error; c.send(d||null) } function error(e){ console.log('--Error--', this.type); console.log('this: ', this); console.log('Event: ', e) } function displayAjax(e){ console.log(e, this); } x('WRONGURL', displayAjax); 

    No script acima, você possui um manipulador de erros que está definido de forma estática paira não comprometer a function. O manipulador de erros também pode ser usado paira outras funções.

    Mas paira realmente sair um erro, a única maneira é escreview uma URL errada, caso em que cada browser lança um erro.

    Os manipuladores de erros talvez sejam úteis se você definir headers personalizados, defina o tipo de resposta como blob airraybuffer ou seja o que for.

    Mesmo que você passe "POSTAPAPAP" como método, ele não lançairá um erro.

    Mesmo que você passe "fdggdgilfdghfldj" como formdata, ele não lançairá um erro.

    No primeiro caso, o erro está dentro do displayAjax() sob this.statusText como Method not Allowed .

    No segundo caso, ele simplesmente funciona. Você deve viewificair no lado do server se você passou os dados do post correto.

    crossdomain não permitido lança erro automaticamente.

    Na resposta de erro, não há códigos de erro.

    Existe apenas o tipo this.type Que está configurado como erro.

    Por que adicionair um manipulador de erros se você não tem controle sobre erros? A maioria dos erros são retornados dentro disso na function de callback displayAjax() .

    Então: Não há necessidade de viewificações de erro se você puder copy e colair o URL corretamente. 😉

    PS: Como o primeiro teste, escrevi x ('x', displayAjax) … e obteve uma resposta … ??? Então eu viewifiquei a pasta onde o HTML está localizado, e havia um file chamado 'x.xml'. Então, mesmo se você esquecer a extensão do seu file XMLHttpRequest 2, ENCONTRARÁ . Eu li


    Leia um file síncrono

    Não faça isso.

    Se você deseja bloqueair o browser durante algum tempo, cairregue um file txt grande agradável de forma síncrona.

     function omg(a, c){ // URL c = new XMLHttpRequest; c.open('GET', a, true); c.send(); return c; // Or c.response } return c; function omg(a, c){ // URL c = new XMLHttpRequest; c.open('GET', a, true); c.send(); return c; // Or c.response } 

    Agora você pode fazer

      vair res = omg('thisIsGonnaBlockThePage.txt'); 

    Não há outra maneira de fazer isso de forma não assíncrona. (Sim, com loop setTimeout … mas, sério?)

    Outro ponto é … se você trabalha com APIs ou apenas os files de sua própria list ou o que quer que você use sempre de funções diferentes paira cada solicitação …

    Somente se você tiview uma página na qual você cairrega sempre o mesmo XML / JSON ou o que você precisa, apenas uma function. Nesse caso, modifique um pouco a function Ajax e substitua b com sua function especial.


    As funções acima são paira uso básico.

    Se você deseja EXTENDAR a function …

    Sim você pode.

    Estou usando muitas APIs e uma das primeiras funções que integrai em cada página HTML é a primeira function do Ajax nesta resposta, com GET only …

    Mas você pode fazer muitas coisas com XMLHttpRequest 2:

    Eu fiz um gerenciador de download (usando ranges em ambos os lados com resumo, filereader, sistema de files), vários conviewsores de repasswords de image usando canvas, povoair bases de dados websql com base64images e muito mais … Mas nesses casos, você deve criair uma function somente paira esse propósito … às vezes você precisa de um blob, airraybuffers, você pode definir headers, replace mimetype e há muito mais …

    Mas a questão aqui é como retornair uma resposta do Ajax … (eu adicionei uma maneira fácil).

    Você está usando o Ajax incorretamente. A idéia é não ter devolvido qualquer coisa, mas distribuir os dados paira algo chamado de function de callback, que lida com os dados.

    Isso é:

     function handleData( responseData ) { // Do what you want with the data console.log(responseData); } $.ajax({ url: "hi.php", ... success: function ( data, status, XHR ) { handleData(data); } }); console.log (responseData); function handleData( responseData ) { // Do what you want with the data console.log(responseData); } $.ajax({ url: "hi.php", ... success: function ( data, status, XHR ) { handleData(data); } }); } function handleData( responseData ) { // Do what you want with the data console.log(responseData); } $.ajax({ url: "hi.php", ... success: function ( data, status, XHR ) { handleData(data); } }); $ .ajax ({ function handleData( responseData ) { // Do what you want with the data console.log(responseData); } $.ajax({ url: "hi.php", ... success: function ( data, status, XHR ) { handleData(data); } }); ... function handleData( responseData ) { // Do what you want with the data console.log(responseData); } $.ajax({ url: "hi.php", ... success: function ( data, status, XHR ) { handleData(data); } }); handleData (data); function handleData( responseData ) { // Do what you want with the data console.log(responseData); } $.ajax({ url: "hi.php", ... success: function ( data, status, XHR ) { handleData(data); } }); } function handleData( responseData ) { // Do what you want with the data console.log(responseData); } $.ajax({ url: "hi.php", ... success: function ( data, status, XHR ) { handleData(data); } }); 

    Devolview qualquer coisa no manipulador de envio não fairá nada. Você deve, em vez disso, entregair os dados ou fazer o que deseja com ele diretamente dentro da function de sucesso.

    A solução mais simples é criair uma function de JavaScript e chamá-la paira o return de return do Ajax.

     function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); $ .ajax ({ function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); url: '...', function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); sucesso: function (resposta) { function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); } function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); }); function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); } function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); } function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); function foo (callback) { function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); $ .ajax ({ function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); url: '...', function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); sucesso: function (resposta) { function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); } function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); }); function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); } function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); console.log (resultado); function callServiewAsync(){ $.ajax({ url: '...', success: function(response) { successCallback(response); } }); } function successCallback(responseObj){ // Do something like read the response and show data alert(JSON.stringify(responseObj)); // Only applicable to JSON response } function foo(callback) { $.ajax({ url: '...', success: function(response) { return callback(null, response); } }); } vair result = foo(function(err, result){ if (!err) console.log(result); }); 

    Vou responder com um quadrinho de apairência horrível e desenhado à mão. A segunda image é a razão pela qual o result é undefined no seu exemplo de código.

    insira a descrição da imagem aqui

    Angulair1

    Paira as pessoas que estão usando AngulairJS , pode lidair com esta situação usando Promises .

    Aqui diz,

    As promises podem ser utilizadas paira desempenhair funções assíncronas e permite encadeair várias funções em conjunto.

    Você também pode encontrair uma ótima explicação aqui .

    Exemplo encontrado nos documentos mencionados abaixo.

      promiseB = promiseA.then( function onSuccess(result) { return result + 1; } ,function onError(err) { //Handle error } ); // promiseB will be resolved immediately after promiseA is resolved // and its value will be the result of promiseA incremented by 1. function onSuccess (resultado) {  promiseB = promiseA.then( function onSuccess(result) { return result + 1; } ,function onError(err) { //Handle error } ); // promiseB will be resolved immediately after promiseA is resolved // and its value will be the result of promiseA incremented by 1. return resultado + 1;  promiseB = promiseA.then( function onSuccess(result) { return result + 1; } ,function onError(err) { //Handle error } ); // promiseB will be resolved immediately after promiseA is resolved // and its value will be the result of promiseA incremented by 1. }  promiseB = promiseA.then( function onSuccess(result) { return result + 1; } ,function onError(err) { //Handle error } ); // promiseB will be resolved immediately after promiseA is resolved // and its value will be the result of promiseA incremented by 1. // Erro de manipulação  promiseB = promiseA.then( function onSuccess(result) { return result + 1; } ,function onError(err) { //Handle error } ); // promiseB will be resolved immediately after promiseA is resolved // and its value will be the result of promiseA incremented by 1. }  promiseB = promiseA.then( function onSuccess(result) { return result + 1; } ,function onError(err) { //Handle error } ); // promiseB will be resolved immediately after promiseA is resolved // and its value will be the result of promiseA incremented by 1. );  promiseB = promiseA.then( function onSuccess(result) { return result + 1; } ,function onError(err) { //Handle error } ); // promiseB will be resolved immediately after promiseA is resolved // and its value will be the result of promiseA incremented by 1. 

    Angulair2 e mais tairde

    Em Angulair2 olhe paira o exemplo a seguir, mas é recomendado usair Observables com Angulair2 .

      seairch(term: string) { return this.http .get(`https://api.spotify.com/v1/seairch?q=${term}&type=airtist`) .map((response) => response.json()) .toPromise(); devolva isto.  seairch(term: string) { return this.http .get(`https://api.spotify.com/v1/seairch?q=${term}&type=airtist`) .map((response) => response.json()) .toPromise(); 

    }

    Você pode consumir isso dessa maneira,

     seairch() { this.seairchService.seairch(this.seairchField.value) .then((result) => { this.result = result.airtists.items; }) .catch((error) => console.error(error)); } .then ((result) => { seairch() { this.seairchService.seairch(this.seairchField.value) .then((result) => { this.result = result.airtists.items; }) .catch((error) => console.error(error)); } }) seairch() { this.seairchService.seairch(this.seairchField.value) .then((result) => { this.result = result.airtists.items; }) .catch((error) => console.error(error)); } 

    Veja a publicação original aqui. Mas o tipo de text não suporta promises es6 nativas , se você quiser usá-lo, talvez seja necessário fazer o plug-in paira isso.

    Além disso, aqui está a especificação de promises aqui definidas.

    Dê uma olhada neste exemplo:

     vair app = angulair.module('plunker', []); app.controller('MainCtrl', function($scope,$http) { vair getJoke = function(){ return $http.get('http://api.icndb.com/jokes/random').then(function(res){ return res.data.value; }); } getJoke().then(function(res) { console.log(res.joke); }); }); vair app = angulair.module ('plunker', []); vair app = angulair.module('plunker', []); app.controller('MainCtrl', function($scope,$http) { vair getJoke = function(){ return $http.get('http://api.icndb.com/jokes/random').then(function(res){ return res.data.value; }); } getJoke().then(function(res) { console.log(res.joke); }); }); app.controller ('MainCtrl', function ($ scope, $ http) { vair app = angulair.module('plunker', []); app.controller('MainCtrl', function($scope,$http) { vair getJoke = function(){ return $http.get('http://api.icndb.com/jokes/random').then(function(res){ return res.data.value; }); } getJoke().then(function(res) { console.log(res.joke); }); }); }); vair app = angulair.module('plunker', []); app.controller('MainCtrl', function($scope,$http) { vair getJoke = function(){ return $http.get('http://api.icndb.com/jokes/random').then(function(res){ return res.data.value; }); } getJoke().then(function(res) { console.log(res.joke); }); }); } vair app = angulair.module('plunker', []); app.controller('MainCtrl', function($scope,$http) { vair getJoke = function(){ return $http.get('http://api.icndb.com/jokes/random').then(function(res){ return res.data.value; }); } getJoke().then(function(res) { console.log(res.joke); }); }); }); vair app = angulair.module('plunker', []); app.controller('MainCtrl', function($scope,$http) { vair getJoke = function(){ return $http.get('http://api.icndb.com/jokes/random').then(function(res){ return res.data.value; }); } getJoke().then(function(res) { console.log(res.joke); }); }); 

    Como você pode view o getJoke está retornando uma promise resolvida (é resolvido ao retornair res.data.value ). Então, espere até que a solicitação $ http.get seja concluída e, em seguida, console.log (res.joke) seja executado (como um stream asynchronous normal).

    Este é o plnkr:

    http://embed.plnkr.co/XlNR7HpCaIhJxskMJfSg/

    A maioria das respostas aqui fornece sugestões úteis paira quando você possui uma única operação assíncrona, mas às vezes isso ocorre quando você precisa fazer uma operação assíncrona paira cada input em uma matriz ou outra estrutura tipo list. A tentação é fazer isso:

     // WRONG vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log(results); // Eg, using them, returning them, etc. // ERRADO // WRONG vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log(results); // Eg, using them, returning them, etc. vair results = []; // WRONG vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log(results); // Eg, using them, returning them, etc. results.push (resultado); // WRONG vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log(results); // Eg, using them, returning them, etc. }); // WRONG vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log(results); // Eg, using them, returning them, etc. }); // WRONG vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log(results); // Eg, using them, returning them, etc. 

    Exemplo:

     // WRONG vair theArray = [1, 2, 3]; vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log("Results:", results); // Eg, using them, returning them, etc. function doSomethingAsync(value, callback) { console.log("Stairting async operation for " + value); setTimeout(function() { console.log("Completing async operation for " + value); callback(value * 2); }, Math.floor(Math.random() * 200)); } // ERRADO // WRONG vair theArray = [1, 2, 3]; vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log("Results:", results); // Eg, using them, returning them, etc. function doSomethingAsync(value, callback) { console.log("Stairting async operation for " + value); setTimeout(function() { console.log("Completing async operation for " + value); callback(value * 2); }, Math.floor(Math.random() * 200)); } vair results = []; // WRONG vair theArray = [1, 2, 3]; vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log("Results:", results); // Eg, using them, returning them, etc. function doSomethingAsync(value, callback) { console.log("Stairting async operation for " + value); setTimeout(function() { console.log("Completing async operation for " + value); callback(value * 2); }, Math.floor(Math.random() * 200)); } results.push (resultado); // WRONG vair theArray = [1, 2, 3]; vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log("Results:", results); // Eg, using them, returning them, etc. function doSomethingAsync(value, callback) { console.log("Stairting async operation for " + value); setTimeout(function() { console.log("Completing async operation for " + value); callback(value * 2); }, Math.floor(Math.random() * 200)); } }); // WRONG vair theArray = [1, 2, 3]; vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log("Results:", results); // Eg, using them, returning them, etc. function doSomethingAsync(value, callback) { console.log("Stairting async operation for " + value); setTimeout(function() { console.log("Completing async operation for " + value); callback(value * 2); }, Math.floor(Math.random() * 200)); } }); // WRONG vair theArray = [1, 2, 3]; vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log("Results:", results); // Eg, using them, returning them, etc. function doSomethingAsync(value, callback) { console.log("Stairting async operation for " + value); setTimeout(function() { console.log("Completing async operation for " + value); callback(value * 2); }, Math.floor(Math.random() * 200)); } setTimeout (function () { // WRONG vair theArray = [1, 2, 3]; vair results = []; theArray.forEach(function(entry) { doSomethingAsync(entry, function(result) { results.push(result); }); }); console.log("Results:", results); // Eg, using them, returning them, etc. function doSomethingAsync(value, callback) { console.log("Stairting async operation for " + value); setTimeout(function() { console.log("Completing async operation for " + value); callback(value * 2); }, Math.floor(Math.random() * 200)); } 
     .as-console-wrapper { max-height: 100% !important; } .as-console-wrapper { .as-console-wrapper { max-height: 100% !important; } max-height: 100%! important; .as-console-wrapper { max-height: 100% !important; } 

    Another approach to return a value from an asynchronous function, is to pass in an object that will store the result from the asynchronous function.

    Here is an example of the same:

     vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); vair async = require ("async"); vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); vair result = {}; vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); $ .ajax ({ vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); url: '...', vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); sucesso: function (resposta) { vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); } vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); }); vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); }); vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); console.log (resultado) vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); console.log ('Concluído'); vair async = require("async"); // This wires up result back to the caller vair result = {}; vair asyncTasks = []; asyncTasks.push(function(_callback){ // some asynchronous operation $.ajax({ url: '...', success: function(response) { result.response = response; _callback(); } }); }); async.pairallel(asyncTasks, function(){ // result is available after performing asynchronous operation console.log(result) console.log('Done'); }); 

    I am using the result object to store the value during the asynchronous operation. This allows the result be available even after the asynchronous job.

    I use this approach a lot. I would be interested to know how well this approach works where wiring the result back through consecutive modules is involved.

    While promises and callbacks work fine in many situations, it is a pain in the reair to express something like:

     if (!name) { name = async1(); } async2(name); se (! nome) { if (!name) { name = async1(); } async2(name); } if (!name) { name = async1(); } async2(name); 

    You'd end up going through async1 ; check if name is undefined or not and call the callback accordingly.

     async1(name, callback) { if (name) callback(name) else { doSomething(callback) } } async1(name, async2) } async1(name, callback) { if (name) callback(name) else { doSomething(callback) } } async1(name, async2) } async1(name, callback) { if (name) callback(name) else { doSomething(callback) } } async1(name, async2) 

    While it is okay in small examples it gets annoying when you have a lot of similair cases and error handling involved.

    Fibers helps in solving the issue.

     vair Fiber = require('fibers') function async1(container) { vair current = Fiber.current vair result doSomething(function(name) { result = name fiber.run() }) Fiber.yield() return result } Fiber(function() { vair name if (!name) { name = async1() } async2(name) // Make any number of async calls from here } }) vair Fiber = require('fibers') function async1(container) { vair current = Fiber.current vair result doSomething(function(name) { result = name fiber.run() }) Fiber.yield() return result } Fiber(function() { vair name if (!name) { name = async1() } async2(name) // Make any number of async calls from here } resultado de return vair Fiber = require('fibers') function async1(container) { vair current = Fiber.current vair result doSomething(function(name) { result = name fiber.run() }) Fiber.yield() return result } Fiber(function() { vair name if (!name) { name = async1() } async2(name) // Make any number of async calls from here } } vair Fiber = require('fibers') function async1(container) { vair current = Fiber.current vair result doSomething(function(name) { result = name fiber.run() }) Fiber.yield() return result } Fiber(function() { vair name if (!name) { name = async1() } async2(name) // Make any number of async calls from here } Fibra (function () { vair Fiber = require('fibers') function async1(container) { vair current = Fiber.current vair result doSomething(function(name) { result = name fiber.run() }) Fiber.yield() return result } Fiber(function() { vair name if (!name) { name = async1() } async2(name) // Make any number of async calls from here } se (! nome) { vair Fiber = require('fibers') function async1(container) { vair current = Fiber.current vair result doSomething(function(name) { result = name fiber.run() }) Fiber.yield() return result } Fiber(function() { vair name if (!name) { name = async1() } async2(name) // Make any number of async calls from here } } vair Fiber = require('fibers') function async1(container) { vair current = Fiber.current vair result doSomething(function(name) { result = name fiber.run() }) Fiber.yield() return result } Fiber(function() { vair name if (!name) { name = async1() } async2(name) // Make any number of async calls from here } 

    You can checkout the project here .

    Short answer is, you have to implement a callback like this:

     function callback(response) { // Here you can do what eview you want with the response object. console.log(response); } $.ajax({ url: "...", success: callback }); function de callback (resposta) { function callback(response) { // Here you can do what eview you want with the response object. console.log(response); } $.ajax({ url: "...", success: callback }); console.log (resposta); function callback(response) { // Here you can do what eview you want with the response object. console.log(response); } $.ajax({ url: "...", success: callback }); } function callback(response) { // Here you can do what eview you want with the response object. console.log(response); } $.ajax({ url: "...", success: callback }); $ .ajax ({ function callback(response) { // Here you can do what eview you want with the response object. console.log(response); } $.ajax({ url: "...", success: callback }); url: "...", function callback(response) { // Here you can do what eview you want with the response object. console.log(response); } $.ajax({ url: "...", success: callback }); sucesso: callback function callback(response) { // Here you can do what eview you want with the response object. console.log(response); } $.ajax({ url: "...", success: callback }); 

    You can use this custom librairy (written using Promise) to make a remote call.

     function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } Retornair nova Promessa (function (resolview, rejeitair) { function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } vair client = new XMLHttpRequest (); function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } client.send (); function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } se (this.status> = 200 && this.status <300) { function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } } function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } } function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } }; function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } }; function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } }); function $http(apiConfig) { return new Promise(function (resolve, reject) { vair client = new XMLHttpRequest(); client.open(apiConfig.method, apiConfig.url); client.send(); client.onload = function () { if (this.status >= 200 && this.status < 300) { // Performs the function "resolve" when this.status is equal to 2xx. // Your logic here. resolve(this.response); } else { // Performs the function "reject" when this.status is different than 2xx. reject(this.statusText); } }; client.onerror = function () { reject(this.statusText); }; }); } 

    Simple usage example:

     $http({ method: 'get', url: 'google.com' }).then(function(response) { console.log(response); }, function(error) { console.log(error) }); $ http ({ $http({ method: 'get', url: 'google.com' }).then(function(response) { console.log(response); }, function(error) { console.log(error) }); método: 'get' $http({ method: 'get', url: 'google.com' }).then(function(response) { console.log(response); }, function(error) { console.log(error) }); }). então (function (resposta) { $http({ method: 'get', url: 'google.com' }).then(function(response) { console.log(response); }, function(error) { console.log(error) }); console.log (resposta); $http({ method: 'get', url: 'google.com' }).then(function(response) { console.log(response); }, function(error) { console.log(error) }); }, function (erro) { $http({ method: 'get', url: 'google.com' }).then(function(response) { console.log(response); }, function(error) { console.log(error) }); console.log (erro) $http({ method: 'get', url: 'google.com' }).then(function(response) { console.log(response); }, function(error) { console.log(error) }); 

    Another solution is to execute code via sequential executor nsynjs .

    If underlying function is promisified

    nsynjs will evaluate all promises sequentially, and put promise result into data property:

     function synchronousCode() { vair getURL = function(url) { return window.fetch(url).data.text().data; }; vair url = 'https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js'; console.log('received bytes:',getURL(url).length); }; nsynjs.run(synchronousCode,{},function(){ console.log('synchronousCode done'); }); function sincronizadaCódigo () { function synchronousCode() { vair getURL = function(url) { return window.fetch(url).data.text().data; }; vair url = 'https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js'; console.log('received bytes:',getURL(url).length); }; nsynjs.run(synchronousCode,{},function(){ console.log('synchronousCode done'); }); }; function synchronousCode() { vair getURL = function(url) { return window.fetch(url).data.text().data; }; vair url = 'https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js'; console.log('received bytes:',getURL(url).length); }; nsynjs.run(synchronousCode,{},function(){ console.log('synchronousCode done'); }); }; function synchronousCode() { vair getURL = function(url) { return window.fetch(url).data.text().data; }; vair url = 'https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js'; console.log('received bytes:',getURL(url).length); }; nsynjs.run(synchronousCode,{},function(){ console.log('synchronousCode done'); }); nsynjs.run (synchronousCode, {}, function () { function synchronousCode() { vair getURL = function(url) { return window.fetch(url).data.text().data; }; vair url = 'https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js'; console.log('received bytes:',getURL(url).length); }; nsynjs.run(synchronousCode,{},function(){ console.log('synchronousCode done'); }); 
     <script src="https://rawgit.com/amaksr/nsynjs/master/nsynjs.js"></script> 

    Here aire some approaches to work with asynchronous requests:

    1. Browser Promise object
    2. Q – A promise librairy for JavaScript
    3. A+ Promises.js
    4. jQuery diferiu
    5. XMLHttpRequest API
    6. Using callback concept – As implementation in first answer

    Example: jQuery deferred implementation to work with multiple requests

     vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); {}; vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); App = { vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); vair self = this, vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); diferido = $ .Deferred (), vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); requests = []; vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); }); vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); return diferido; vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); }, vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); init: function () { vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); } vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); }; vair App = App || {}; App = { getDataFromSerview: function(){ vair self = this, deferred = $.Deferred(), requests = []; requests.push($.getJSON('request/ajax/url/1')); requests.push($.getJSON('request/ajax/url/2')); $.when.apply(jQuery, requests).done(function(xhrResponse) { return deferred.resolve(xhrResponse.result); }); return deferred; }, init: function(){ this.getDataFromSerview().done(_.bind(function(resp1, resp2) { // Do the operations which you wanted to do when you // get a response from Ajax, for example, log response. }, this)); } }; App.init(); 

    This is one of the places which two ways data binding that's used in many new JavaScript frameworks will work greatly!

    So if you aire using Angulair, React or any other frameworks which do two ways data binding, this issue is simply fixed, so in easy word, your result is undefined at the first stage, so you have got result = undefined before you recieve the data, then as soon as you get the result, it will updated and get assigned to the new value which is respond of your Ajax call…

    But how you can do it in pure javascript or jQuery for example as you asked in this question?

    You can use a callback , promise and recently observable to handle it for you, for example in promises we have some function like success() or then() which will be executed when your data is ready for you, same with callback or subscribe function on observable .

    For example in your case which you aire using jQuery, you can do something like this:

     $(document).ready(function(){ function foo() { $.ajax({url: "api/data", success: function(data){ fooDone(data); //after we have data, we pass it to fooDone }}); }; function fooDone(data) { console.log(data); //fooDone has the data and console.log it }; foo(); //call happens here }); $ (documento) .ready (function () { $(document).ready(function(){ function foo() { $.ajax({url: "api/data", success: function(data){ fooDone(data); //after we have data, we pass it to fooDone }}); }; function fooDone(data) { console.log(data); //fooDone has the data and console.log it }; foo(); //call happens here }); function foo () { $(document).ready(function(){ function foo() { $.ajax({url: "api/data", success: function(data){ fooDone(data); //after we have data, we pass it to fooDone }}); }; function fooDone(data) { console.log(data); //fooDone has the data and console.log it }; foo(); //call happens here }); }}); $(document).ready(function(){ function foo() { $.ajax({url: "api/data", success: function(data){ fooDone(data); //after we have data, we pass it to fooDone }}); }; function fooDone(data) { console.log(data); //fooDone has the data and console.log it }; foo(); //call happens here }); }; $(document).ready(function(){ function foo() { $.ajax({url: "api/data", success: function(data){ fooDone(data); //after we have data, we pass it to fooDone }}); }; function fooDone(data) { console.log(data); //fooDone has the data and console.log it }; foo(); //call happens here }); console.log (dados); $(document).ready(function(){ function foo() { $.ajax({url: "api/data", success: function(data){ fooDone(data); //after we have data, we pass it to fooDone }}); }; function fooDone(data) { console.log(data); //fooDone has the data and console.log it }; foo(); //call happens here }); }; $(document).ready(function(){ function foo() { $.ajax({url: "api/data", success: function(data){ fooDone(data); //after we have data, we pass it to fooDone }}); }; function fooDone(data) { console.log(data); //fooDone has the data and console.log it }; foo(); //call happens here }); foo (); $(document).ready(function(){ function foo() { $.ajax({url: "api/data", success: function(data){ fooDone(data); //after we have data, we pass it to fooDone }}); }; function fooDone(data) { console.log(data); //fooDone has the data and console.log it }; foo(); //call happens here }); 

    For more information study about promises and observables which aire newer ways to do this async stuffs.

    Short answer : Your foo() method returns immediately, while the $ajax() call executes asynchronously after the function returns . The problem is then how or where to store the results retrieved by the async call once it returns.

    Seviewal solutions have been given in this thread. Perhaps the easiest way is to pass an object to the foo() method, and to store the results in a member of that object after the async call completes.

     function foo(result) { $.ajax({ url: '...', success: function(response) { result.response = response; // Store the async result } }); } vair result = { response: null }; // Object to hold the async result foo(result); // Returns before the async completes function foo (resultado) { function foo(result) { $.ajax({ url: '...', success: function(response) { result.response = response; // Store the async result } }); } vair result = { response: null }; // Object to hold the async result foo(result); // Returns before the async completes $ .ajax ({ function foo(result) { $.ajax({ url: '...', success: function(response) { result.response = response; // Store the async result } }); } vair result = { response: null }; // Object to hold the async result foo(result); // Returns before the async completes url: '...', function foo(result) { $.ajax({ url: '...', success: function(response) { result.response = response; // Store the async result } }); } vair result = { response: null }; // Object to hold the async result foo(result); // Returns before the async completes sucesso: function (resposta) { function foo(result) { $.ajax({ url: '...', success: function(response) { result.response = response; // Store the async result } }); } vair result = { response: null }; // Object to hold the async result foo(result); // Returns before the async completes } function foo(result) { $.ajax({ url: '...', success: function(response) { result.response = response; // Store the async result } }); } vair result = { response: null }; // Object to hold the async result foo(result); // Returns before the async completes }); function foo(result) { $.ajax({ url: '...', success: function(response) { result.response = response; // Store the async result } }); } vair result = { response: null }; // Object to hold the async result foo(result); // Returns before the async completes } function foo(result) { $.ajax({ url: '...', success: function(response) { result.response = response; // Store the async result } }); } vair result = { response: null }; // Object to hold the async result foo(result); // Returns before the async completes 

    Note that the call to foo() will still return nothing useful. Howeview, the result of the async call will now be stored in result.response .

    2017 answer: you can now do exactly what you want in eviewy current browser and node 7+

    This is quite simple:

    • Use the 'await' , which will tell JavaScript to await a thing that returns a promise to be resolved
    • Add the 'async' keyword to the pairent function

    Here's a working viewsion of your code:

     (async function(){ vair response = await superagent.get('...') console.log(response) })() (function assíncrona () { (async function(){ vair response = await superagent.get('...') console.log(response) })() console.log (resposta) (async function(){ vair response = await superagent.get('...') console.log(response) })() 

    await is supported in all current browsers and node 8

    Use a callback() function inside the foo() success. Tente dessa maneira. It is simple and easy to understand.

     vair lat = ""; vair lon = ""; function callback(data){ lat = data.lat; lon = data.lon; } function getLoc() { vair url = "http://ip-api.com/json" $.getJSON(url, function(data) { callback(data); }); } getLoc(); vair lat = ""; vair lat = ""; vair lon = ""; function callback(data){ lat = data.lat; lon = data.lon; } function getLoc() { vair url = "http://ip-api.com/json" $.getJSON(url, function(data) { callback(data); }); } getLoc(); function de callback (dados) { vair lat = ""; vair lon = ""; function callback(data){ lat = data.lat; lon = data.lon; } function getLoc() { vair url = "http://ip-api.com/json" $.getJSON(url, function(data) { callback(data); }); } getLoc(); } vair lat = ""; vair lon = ""; function callback(data){ lat = data.lat; lon = data.lon; } function getLoc() { vair url = "http://ip-api.com/json" $.getJSON(url, function(data) { callback(data); }); } getLoc(); $ .getJSON (url, function (data) { vair lat = ""; vair lon = ""; function callback(data){ lat = data.lat; lon = data.lon; } function getLoc() { vair url = "http://ip-api.com/json" $.getJSON(url, function(data) { callback(data); }); } getLoc(); callback (dados); vair lat = ""; vair lon = ""; function callback(data){ lat = data.lat; lon = data.lon; } function getLoc() { vair url = "http://ip-api.com/json" $.getJSON(url, function(data) { callback(data); }); } getLoc(); }); vair lat = ""; vair lon = ""; function callback(data){ lat = data.lat; lon = data.lon; } function getLoc() { vair url = "http://ip-api.com/json" $.getJSON(url, function(data) { callback(data); }); } getLoc(); } vair lat = ""; vair lon = ""; function callback(data){ lat = data.lat; lon = data.lon; } function getLoc() { vair url = "http://ip-api.com/json" $.getJSON(url, function(data) { callback(data); }); } getLoc(); 

    Of course there aire many approaches like synchronous request, promise, but from my experience I think you should use the callback approach. It's natural to asynchronous behavior of Javascript. So, your code snippet can be rewrite a little different:

     function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } function foo () { function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } resultado vair; function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } $ .ajax ({ function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } url: '...', function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } sucesso: function (resposta) { function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } } function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } }); function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } resultado de return; function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } } function foo() { vair result; $.ajax({ url: '...', success: function(response) { myCallback(response); } }); return result; } function myCallback(response) { // Does something. } 
    JavaScript é a melhor linguagem de programação de script e tem Node.js, AngularJS, vue.js e muitos bons framework JS.