**Merk: Dette svaret ble skrevet i februar 2010. Se oppdateringer fra 2015, 2016 og 2017 nederst. Du kan ikke returnere noe fra en funksjon som er asynkron. Det du kan returnere er et løfte*. Jeg forklarte hvordan løfter fungerer i jQuery i svarene mine på disse spørsmålene:

• JavaScript-funksjon som returnerer AJAX-anropsdata
• jQuery jqXHR - avbryte kjedede anrop, utløse feilkjede Hvis du kan forklare hvorfor du vil returnere dataene og hva du vil gjøre med dem senere, kan jeg kanskje gi deg et mer spesifikt svar på hvordan du gjør det. Generelt, i stedet for:

function testAjax() {
  $.ajax({
    url: "getvalue.php",  
    success: function(data) {
      return data; 
    }
  });
}

kan du skrive testAjax-funksjonen din slik:

function testAjax() {
  return $.ajax({
      url: "getvalue.php"
  });
}

Da kan du få løftet ditt slik:

var promise = testAjax();

Du kan lagre løftet ditt, du kan sende det rundt, du kan bruke det som et argument i funksjonskall og du kan returnere det fra funksjoner, men når du til slutt vil bruke dataene dine som returneres av AJAX-kallet, må du gjøre det slik:

promise.success(function (data) {
  alert(data);
});

(Se oppdateringer nedenfor for forenklet syntaks.). Hvis dataene dine er tilgjengelige på dette tidspunktet, vil denne funksjonen påkalles umiddelbart. Hvis den ikke er det, vil den bli påkalt så snart dataene er tilgjengelige. Hele poenget med å gjøre alt dette er at dataene dine ikke er tilgjengelige umiddelbart etter kallet til $.ajax fordi det er asynkront. Løfter er en fin abstraksjon for funksjoner å si: Jeg kan ikke returnere dataene fordi jeg ikke har dem ennå, og jeg vil ikke blokkere og få deg til å vente, så her er et løfte i stedet, og du vil kunne bruke det senere, eller bare gi det til noen andre og være ferdig med det. Se denne [DEMO](http://jsfiddle.net/jW68r/). OPPDATERING (2015)

For øyeblikket (per mars 2015) er jQuery Promises ikke kompatibelt med Promises/A+-spesifikasjonen, noe som betyr at de kanskje ikke samarbeider særlig godt med andre Promises/A+-konforme implementeringer. Men jQuery Promises i den kommende versjonen 3.x vil være kompatibel med Promises/A+-spesifikasjonen (takk til Benjamin Gruenbaum for å ha påpekt det). For øyeblikket (per mai 2015) er de stabile versjonene av jQuery 1.x og 2.x.

Det jeg forklarte ovenfor (i mars 2011) er en måte å bruke jQuery Deferred Objects for å gjøre noe asynkront som i synkron kode ville oppnås ved å returnere en verdi. Men et synkront funksjonskall kan gjøre to ting - det kan enten returnere en verdi (hvis det kan) eller kaste et unntak (hvis det ikke kan returnere en verdi). Løfter / A + adresserer begge disse brukstilfellene på en måte som er ganske mye så kraftig som unntakshåndtering i synkron kode. JQuery-versjonen håndterer ekvivalenten til å returnere en verdi helt fint, men ekvivalenten til kompleks unntakshåndtering er noe problematisk. Spesielt er hele poenget med unntakshåndtering i synkron kode ikke bare å gi opp med en fin melding, men å prøve å løse problemet og fortsette kjøringen, eller muligens kaste det samme eller et annet unntak for noen andre deler av programmet å håndtere. I synkron kode har du en anropsstabel. I asynkron samtale har du ikke det, og avansert unntakshåndtering inne i løftene dine som kreves av Promises / A + -spesifikasjonen kan virkelig hjelpe deg med å skrive kode som vil håndtere feil og unntak på en meningsfull måte, selv for komplekse brukstilfeller. For forskjeller mellom jQuery og andre implementeringer, og hvordan du konverterer jQuery-løfter til Promises/A+-kompatible, se Coming from jQuery av Kris Kowal et al. på Q-bibliotekets wiki og Promises arrive in JavaScript av Jake Archibald på HTML5 Rocks.

Hvordan returnere et ekte løfte

Funksjonen fra mitt eksempel ovenfor:

function testAjax() {
  return $.ajax({
      url: "getvalue.php"
  });
}

returnerer et jqXHR-objekt, som er et jQuery Deferred Object. For å få det til å returnere et ekte løfte, kan du endre det til - ved hjelp av metoden fra Q wiki:

function testAjax() {
  return Q($.ajax({
      url: "getvalue.php"
  }));
}

eller ved å bruke metoden fra HTML5 Rocks-artikkelen:

function testAjax() {
  return Promise.resolve($.ajax({
      url: "getvalue.php"
  }));
}

Denne Promise.resolve($.ajax(...)) er også forklart i dokumentasjonen for promise-modulen, og den skal fungere med ES6 Promise.resolve(). For å bruke ES6 Promises i dag kan du bruke es6-promise-modulens polyfill() av Jake Archibald. For å se hvor du kan bruke ES6 Promises uten polyfill, se: Kan jeg bruke: Promises. For mer informasjon, se:

• http://bugs.jquery.com/ticket/14510
• https://github.com/jquery/jquery/issues/1722
• https://gist.github.com/domenic/3889970
• http://promises-aplus.github.io/promises-spec/
• http://www.html5rocks.com/en/tutorials/es6/promises/

  Fremtiden til jQuery

  Fremtidige versjoner av jQuery (fra og med 3.x - nåværende stabile versjoner per mai 2015 er 1.x og 2.x) vil være kompatible med Promises/A+-spesifikasjonen (takk til Benjamin Gruenbaum for å påpeke det i kommentarene). "To endringer som vi allerede har bestemt oss for er Promise/A+-kompatibilitet for vår utsatte implementering [...]" (jQuery 3.0 og fremtiden for webutvikling). For mer informasjon, se: jQuery 3.0: The Next Generations av Dave Methvin og jQuery 3.0: More interoperability, less Internet Explorer av Paul Krill.

  Interessante foredrag

• Boom, Promises/A+ Was Born](http://youtu.be/V2Q13hzTGmA) av Domenic Denicola (JSConfUS 2013).
• [Redemption from Callback Hell](http://youtu.be/hf1T_AONQJU) av Michael Jackson og Domenic Denicola (HTML5DevConf 2013)

• [JavaScript Promises](https://youtu.be/oa2clhsYIDY) av David M. Lee (Nodevember 2014) OPPDATERING (2016)

  Det finnes en ny syntaks i ECMA-262, 6th Edition, Section 14.2 kalt arrow functions som kan brukes til å forenkle eksemplene ovenfor ytterligere. Bruk av jQuery API, i stedet for:

promise.success(function (data) {
  alert(data);
});

kan du skrive:

promise.success(data => alert(data));

eller bruke Promises/A+ API:

promise.then(data => alert(data));

Husk å alltid bruke rejection handlers enten med:

promise.then(data => alert(data), error => alert(error));

eller med:

promise.then(data => alert(data)).catch(error => alert(error));

Se dette svaret for å se hvorfor du alltid bør bruke rejection handlers med promises:

• https://stackoverflow.com/questions/40920179/should-i-refrain-from-handling-promise-rejection-asynchronously/40921505#40921505 I dette eksempelet kan du selvfølgelig bare bruke promise.then(alert) fordi du bare kaller alert med de samme argumentene som tilbakeringingen din, men pil-syntaksen er mer generell og lar deg skrive ting som:

promise.then(data => alert("x is " + data.x));

Ikke alle nettlesere støtter denne syntaksen ennå, men det er visse tilfeller der du er sikker på hvilken nettleser koden din vil kjøre på - f.eks. når du skriver en Chrome-utvidelse, et Firefox-tillegg eller en skrivebordsapplikasjon som bruker Electron, NW.js eller AppJS (se dette svaret for detaljer). For støtte for pilfunksjoner, se:

• http://caniuse.com/#feat=arrow-functions
• http://kangax.github.io/compat-table/es6/#test-arrow_functions OPPDATERING (2017)

• Det er en enda nyere syntaks akkurat nå kalt async-funksjoner med et nytt await nøkkelord som i stedet for denne koden:

functionReturningPromise()
    .then(data => console.log('Data:', data))
    .catch(error => console.log('Error:', error));

lar deg skrive:

try {
    let data = await functionReturningPromise();
    console.log('Data:', data);
} catch (error) {
    console.log('Error:', error);
}

Du kan bare bruke det inne i en funksjon som er opprettet med nøkkelordet async. For mer informasjon, se:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await For støtte i nettlesere, se:
• http://caniuse.com/async-functions For støtte i Node, se:
• http://node.green/#ES2017-features-async-functions På steder der du ikke har innebygd støtte for async og await kan du bruke Babel:
• https://babeljs.io/docs/plugins/transform-async-to-generator/ eller med en litt annen syntaks en generatorbasert tilnærming som i co eller Bluebird coroutines:
• https://www.npmjs.com/package/co

• http://bluebirdjs.com/docs/api/promise.coroutine.html Mer info

  Noen andre spørsmål om løfter for mer informasjon:

• https://stackoverflow.com/questions/40720512/promise-call-separate-from-promise-resolution/40721397#40721397
• Q Promise delay
• Returner løfte resultat i stedet for løfte
• Eksportere modul fra løfte resultat
• https://stackoverflow.com/questions/41284107/what-is-wrong-with-promise-resolving/41284674#41284674
• https://stackoverflow.com/questions/40785769/return-value-in-function-from-a-promise-block/40785901#40785901
• https://stackoverflow.com/questions/39764599/how-can-i-return-status-inside-the-promise/39765591#39765591
• https://stackoverflow.com/questions/40920179/should-i-refrain-from-handling-promise-rejection-asynchronously/40921505#40921505
• https://stackoverflow.com/questions/11845328/is-the-deferred-promise-concept-in-javascript-a-new-one-or-is-it-a-traditional-p/11845403#11845403
• https://stackoverflow.com/questions/39659829/how-can-i-chain-these-functions-together-with-promises/39660257#39660257
• https://stackoverflow.com/questions/40643386/promise-all-in-javascript-how-to-get-resolve-value-for-all-promises/40643489#40643489
• Why Promise.all is undefined (Hvorfor Promise.all ikke er definert)
• https://stackoverflow.com/questions/42071337/function-will-return-null-from-javascript-post-get/42072290#42072290
• https://stackoverflow.com/questions/40515775/use-cancel-inside-a-then-chain-created-by-promisifyall/40515981#40515981
• https://stackoverflow.com/questions/42094764/why-is-it-possible-to-pass-in-a-non-function-parameter-to-promise-then-without/42094874#42094874
• https://stackoverflow.com/questions/15245867/implement-promises-pattern/15246695#15246695
• Løfter og ytelse
• Problemer med å skrape to nettadresser med løfter
• http.request returnerer ikke data selv etter å ha spesifisert retur på hendelsen 'end'
• https://stackoverflow.com/questions/41567353/async-each-not-iterating-when-using-promises/41567712#41567712
• https://stackoverflow.com/questions/5111695/jquery-jqxhr-cancel-chained-calls-trigger-error-chain/5112734#5112734
• https://stackoverflow.com/questions/39661064/correct-way-of-handling-promisses-and-server-response/39661503#39661503
• Returnerer en verdi fra et funksjonskall før alle operasjoner i selve funksjonen er fullført?
• https://stackoverflow.com/questions/40729806/resolving-a-settimeout-inside-api-endpoint/40730062#40730062
• https://stackoverflow.com/questions/40741374/async-wait-for-a-function/40741587#40741587
• https://stackoverflow.com/questions/5150571/javascript-function-that-returns-ajax-call-data/5150650#5150650
• https://stackoverflow.com/questions/40884153/try-catch-blocks-with-async-await/40886720#40886720
• https://stackoverflow.com/questions/5159304/jquery-deferred-not-calling-the-resolve-done-callbacks-in-order/5159765#5159765
• https://stackoverflow.com/questions/12660596/returning-data-from-ajax-results-in-strange-object/12660711#12660711
• https://stackoverflow.com/questions/40523091/javascript-why-is-there-a-spec-for-sync-and-async-modules/40525271#40525271

Den eneste måten å returnere dataene fra funksjonen ville være å foreta et synkront kall i stedet for et asynkront kall, men det ville fryse nettleseren mens den venter på svaret.

Du kan sende inn en tilbakeringingsfunksjon som håndterer resultatet:

function testAjax(handleData) {
  $.ajax({
    url:"getvalue.php",  
    success:function(data) {
      handleData(data); 
    }
  });
}

Kall den slik:

testAjax(function(output){
  // here you use the output
});
// Note: the call won't wait for the result,
// so it will continue with the code here while waiting.

Se eksempel på jquery-dokumenter: http://api.jquery.com/jQuery.ajax/ (ca. 2/3 av siden)

Du leter kanskje etter følgende kode:

    $.ajax({
     url: 'ajax/test.html',
     success: function(data) {
     $('.result').html(data);
     alert('Load was performed.');
   }
});

Samme side...lenger ned.