Bemærk: Dette svar blev skrevet i februar 2010.
Se opdateringer fra 2015, 2016 og 2017 nederst. Du kan ikke returnere noget fra en funktion, der er asynkron. Det, du kan returnere, er et løfte. Jeg forklarede, hvordan promises fungerer i jQuery i mine svar på disse spørgsmål:

• [JavaScript-funktion, der returnerer data fra AJAX-opkald] (https://stackoverflow.com/questions/5150571/javascript-function-that-returns-ajax-call-data/5150650#5150650)
• jQuery jqXHR - annullere kædeopkald, udløse fejlkæde Hvis du kunne forklare hvorfor du ønsker at returnere dataene, og hvad du ønsker at gøre med dem senere, så kan jeg måske give dig et mere specifikt svar på, hvordan du skal gøre det. Generelt set, i stedet for:

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

kan du skrive din testAjax-funktion sådan her:

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

Så kan du få dit løfte på denne måde:

var promise = testAjax();

Du kan gemme dit løfte, du kan sende det rundt, du kan bruge det som et argument i funktionsopkald og du kan returnere det fra funktioner, men når du endelig vil bruge dine data, der returneres af AJAX-opkaldet, skal du gøre det sådan her:

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

(Se opdateringer nedenfor for forenklet syntaks.) Hvis dine data er tilgængelige på dette tidspunkt, vil denne funktion blive påberåbt med det samme. Hvis den ikke er det, vil den blive påberåbt, så snart dataene er tilgængelige. Hele pointen med at gøre alt dette er, at dine data ikke er tilgængelige umiddelbart efter opkaldet til $.ajax, fordi det er asynkront. Promises er en dejlig abstraktion for funktioner til at sige: Jeg kan ikke returnere dataene til dig, fordi jeg ikke har dem endnu, og jeg vil ikke blokere og lade dig vente, så her er et løfte i stedet, så du kan bruge dem senere, eller bare give dem til en anden og være færdig med dem. Se denne [DEMO](http://jsfiddle.net/jW68r/). UPDATE (2015)

I øjeblikket (fra marts 2015) er jQuery Promises ikke kompatible med Promises/A+-specifikationen, hvilket betyder, at de muligvis ikke samarbejder særlig godt med andre Promises/A+-konforme implementeringer. Men jQuery Promises i den kommende version 3.x vil være kompatible med Promises/A+-specifikationen (tak til Benjamin Gruenbaum for at gøre opmærksom på det). I øjeblikket (fra maj 2015) er de stabile versioner af jQuery 1.x og 2.x.

Det, jeg forklarede ovenfor (i marts 2011), er en måde at bruge jQuery Deferred Objects til at gøre noget asynkront, som i synkron kode ville blive opnået ved at returnere en værdi. Men et synkront funktionskald kan gøre to ting - det kan enten returnere en værdi (hvis det kan) eller kaste en undtagelse (hvis det ikke kan returnere en værdi). Promises/A+ tager begge disse anvendelsestilfælde op på en måde, der er stort set lige så effektiv som undtagelseshåndtering i synkron kode. JQuery-versionen håndterer det tilsvarende med at returnere en værdi fint, men det tilsvarende med kompleks undtagelseshåndtering er noget problematisk. Især er hele pointen med undtagelseshåndtering i synkron kode ikke bare at give op med en pæn besked, men at forsøge at løse problemet og fortsætte eksekveringen, eller eventuelt at genkaste den samme eller en anden undtagelse, så andre dele af programmet kan håndtere den. I synkron kode har man en call stack. I asynkrone kald har man ikke det, og avanceret undtagelseshåndtering inden for dine promises som krævet i Promises/A+-specifikationen kan virkelig hjælpe dig med at skrive kode, der håndterer fejl og undtagelser på en meningsfuld måde, selv i komplekse brugssituationer. For forskelle mellem jQuery og andre implementeringer, og hvordan man konverterer jQuery-promiser til Promises/A+-kompatible, se Coming from jQuery af Kris Kowal et al. på Q-bibliotekets wiki og Promises arrive in JavaScript af Jake Archibald på HTML5 Rocks.

Sådan returnerer du et rigtigt løfte

Funktionen fra mit eksempel ovenfor:

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

returnerer et jqXHR-objekt, som er et jQuery Deferred Object. For at få den til at returnere et rigtigt løfte, kan du ændre det til - ved hjælp af metoden fra Q-wikien:

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

eller ved hjælp af metoden fra HTML5 Rocks-artiklen:

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

Denne Promise.resolve($.ajax(...)) er også det, der er forklaret i promise-modulets dokumentation, og det burde fungere med ES6 Promise.resolve(). For at bruge ES6 Promises i dag kan du bruge es6-promise module's polyfill() af Jake Archibald. For at se hvor du kan bruge ES6 Promises uden polyfill, se: Can I use: Promises. For yderligere oplysninger 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 for jQuery

  Fremtidige versioner af jQuery (fra og med 3.x - de nuværende stabile versioner fra maj 2015 er 1.x og 2.x) vil være kompatible med Promises/A+-specifikationen (tak til Benjamin Gruenbaum for at gøre opmærksom på det i kommentarerne). "To ændringer, som vi allerede har besluttet, er Promise/A+-kompatibilitet for vores Deferred-implementering [...]" (jQuery 3.0 and the future of Web development)). For mere information se: jQuery 3.0: The Next Generations af Dave Methvin og jQuery 3.0: More interoperability, less Internet Explorer af Paul Krill.

  Interessante foredrag

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

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

  Der findes en ny syntaks i ECMA-262, 6th Edition, Section 14.2 kaldet arrow functions, som kan bruges til at forenkle ovenstående eksempler yderligere. Ved brug af jQuery API'et kan man i stedet for:

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

kan du skrive:

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

eller ved hjælp af Promises/A+ API'et:

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

Husk at du altid skal bruge afvisningshåndteringsprogrammer enten med:

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

eller med:

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

Se dette svar for at se, hvorfor du altid skal bruge afvisningshåndteringsprogrammer med løfter:

• https://stackoverflow.com/questions/40920179/should-i-refrain-from-handling-promise-rejection-asynchronously/40921505#40921505 Selvfølgelig kunne du i dette eksempel bare bruge promise.then(alert), fordi du'bare kalder alert med de samme argumenter som din callback, men pilesyntaksen er mere generel og lader dig skrive ting som f.eks:

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

Ikke alle browsere understøtter denne syntaks endnu, men der er visse tilfælde, hvor du er sikker på, hvilken browser din kode skal køre i - f.eks. når du skriver en Chrome-udvidelse, en Firefox-udvidelse eller en desktop-applikation ved hjælp af Electron, NW.js eller AppJS (se dette svar for nærmere oplysninger). For understøttelse af pilefunktioner, se:

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

• Der er en endnu nyere syntaks lige nu kaldet async-funktioner med et nyt nøgleord await, der i stedet for denne kode:

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

lader dig skrive:

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

Du kan kun bruge det inden for en funktion oprettet med nøgleordet async. For mere information, 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 understøttelse i browsere, se:
• http://caniuse.com/async-functions For support i Node, se:
• http://node.green/#ES2017-features-async-functions På steder hvor du ikke har native understøttelse af async og await kan du bruge Babel:
• https://babeljs.io/docs/plugins/transform-async-to-generator/ eller med en lidt anderledes syntaks en generatorbaseret tilgang som i co eller Bluebird coroutines:
• https://www.npmjs.com/package/co

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

  Nogle andre spørgsmål om promises for flere detaljer:

• https://stackoverflow.com/questions/40720512/promise-call-separate-from-promise-resolution/40721397#40721397
• Q Promise delay
• Returnerer resultat af løfte i stedet for løfte
• Eksport af modul fra resultat af løfte
• 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
• Hvorfor Promise.all er udefineret
• 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 præstationer
• Problemer med at skrabe to URL'er med løfter
• http.request returnerer ikke data, selv efter angivelse af return på 'end' event
• 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 værdi fra et funktionskald før alle operationer i selve funktionen er afsluttet
• 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åde at returnere dataene fra funktionen på ville være at foretage et synkront opkald i stedet for et asynkront opkald, men det ville fastfryse browseren, mens den venter på svaret.

Du kan indsætte en callback-funktion, der håndterer resultatet:

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

Kald den sådan her:

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 jquery docs eksempel: http://api.jquery.com/jQuery.ajax/ (ca. 2/3 af siden)

Du leder måske efter følgende kode:

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

Samme side...længere nede.