Nota: Questa risposta è stata scritta nel febbraio 2010.
Vedi gli aggiornamenti del 2015, 2016 e 2017 in fondo. Non si può restituire nulla da una funzione asincrona. Quello che si può restituire è una promessa. Ho spiegato come funzionano le promesse in jQuery nelle mie risposte a queste domande:

• Funzione JavaScript che restituisce i dati della chiamata AJAX
• jQuery jqXHR - annulla le chiamate concatenate, scatena la catena di errori Se potessi spiegare perché vuoi restituire i dati e cosa vuoi fare con esso in seguito, allora potrei essere in grado di darti una risposta più specifica su come farlo. In generale, invece di:

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

puoi scrivere la tua funzione testAjax come questa:

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

Poi puoi ottenere la tua promessa in questo modo:

var promise = testAjax();

Puoi memorizzare la tua promessa, puoi passarla in giro, puoi usarla come argomento nelle chiamate di funzione e puoi restituirla dalle funzioni, ma quando finalmente vuoi usare i tuoi dati restituiti dalla chiamata AJAX, devi farlo in questo modo:

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

(Vedi gli aggiornamenti qui sotto per una sintassi semplificata.) Se i vostri dati sono disponibili a questo punto, allora questa funzione sarà invocata immediatamente. Se non lo sono, sarà invocata non appena i dati saranno disponibili. L'intero punto di fare tutto questo è che i vostri dati non sono disponibili immediatamente dopo la chiamata a $.ajax perché è asincrona. Le promesse sono una bella astrazione per le funzioni per dire: Non posso restituirti i dati perché non li ho ancora e non voglio bloccarti e farti aspettare, quindi eccoti una promessa e potrai usarla più tardi, o semplicemente darla a qualcun altro e farla finita. Vedi questo [DEMO](http://jsfiddle.net/jW68r/). AGGIORNAMENTO (2015)

Attualmente (a marzo 2015) i Promises di jQuery non sono compatibili con la specifica Promises/A+ il che significa che potrebbero non cooperare molto bene con altre implementazioni Promises/A+ conformant. Tuttavia jQuery Promises nella prossima versione 3.x sarà compatibile con la specifica Promises/A+ (grazie a Benjamin Gruenbaum per averlo segnalato). Attualmente (a maggio 2015) le versioni stabili di jQuery sono 1.x e 2.x.

Quello che ho spiegato sopra (nel marzo 2011) è un modo per usare jQuery Deferred Objects per fare qualcosa in modo asincrono che nel codice sincrono sarebbe stato ottenuto restituendo un valore. Ma una chiamata di funzione sincrona può fare due cose - può restituire un valore (se può) o lanciare un'eccezione (se non può restituire un valore). Promises/A+ affronta entrambi questi casi d'uso in un modo che è abbastanza potente come la gestione delle eccezioni nel codice sincrono. La versione jQuery gestisce bene l'equivalente della restituzione di un valore, ma l'equivalente della gestione delle eccezioni complesse è un po' problematica. In particolare, l'intero punto della gestione delle eccezioni nel codice sincrono non è solo arrendersi con un bel messaggio, ma cercare di risolvere il problema e continuare l'esecuzione, o eventualmente rilanciare la stessa o una diversa eccezione per altre parti del programma da gestire. Nel codice sincrono si ha uno stack di chiamate. Nella chiamata asincrona no, e la gestione avanzata delle eccezioni all'interno delle promesse come richiesto dalla specifica Promises/A+ può davvero aiutare a scrivere codice che gestirà errori ed eccezioni in modo significativo anche per casi d'uso complessi. Per le differenze tra jQuery e altre implementazioni, e come convertire le promesse di jQuery in Promises/A+ compliant, vedere Coming from jQuery di Kris Kowal et al. sul wiki della libreria Q e Promises arrive in JavaScript di Jake Archibald su HTML5 Rocks.

Come restituire una vera promessa

La funzione del mio esempio sopra:

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

restituisce un oggetto jqXHR, che è un jQuery Deferred Object. Per far sì che restituisca una vera promessa, puoi cambiarla in - usando il metodo dal wiki di Q:

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

oppure, usando il metodo dall'articolo HTML5 Rocks:

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

Questo Promise.resolve($.ajax(...)) è anche quello che è spiegato nella documentazione del modulo promise e dovrebbe funzionare con ES6 Promise.resolve(). Per usare le Promesse ES6 oggi potete usare es6-promise module's polyfill() di Jake Archibald. Per vedere dove puoi usare le Promesse ES6 senza il polyfill, vedi: Posso usare: Promises. Per ulteriori informazioni vedere:

• 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/

  Il futuro di jQuery

  Le future versioni di jQuery (a partire dalla 3.x - le attuali versioni stabili a maggio 2015 sono la 1.x e la 2.x) saranno compatibili con la specifica Promises/A+ (grazie a Benjamin Gruenbaum per averlo segnalato nei commenti). "Due cambiamenti che abbiamo già deciso sono la compatibilità Promise/A+ per la nostra implementazione Deferred [...]" (jQuery 3.0 e il futuro dello sviluppo Web). Per maggiori informazioni vedere: jQuery 3.0: The Next Generations di Dave Methvin e jQuery 3.0: più interoperabilità, meno Internet Explorer di Paul Krill.

  Colloqui interessanti

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

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

  C'è una nuova sintassi in ECMA-262, 6th Edition, Section 14.2 chiamata arrow functions che può essere usata per semplificare ulteriormente gli esempi sopra. Usando l'API jQuery, invece di:

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

si può scrivere:

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

o usando l'API Promises/A+:

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

Ricorda di usare sempre gestori di rifiuto o con:

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

o con:

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

Vedi questa risposta per vedere perché dovresti sempre usare i gestori di rifiuto con le promesse:

• https://stackoverflow.com/questions/40920179/should-i-refrain-from-handling-promise-rejection-asynchronously/40921505#40921505 Naturalmente in questo esempio potresti usare solo promise.then(alert) perché stai solo chiamando alert con gli stessi argomenti della tua callback, ma la sintassi della freccia è più generale e ti permette di scrivere cose come:

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

Non tutti i browser supportano ancora questa sintassi, ma ci sono alcuni casi in cui sei sicuro su quale browser il tuo codice verrà eseguito - ad esempio quando scrivi una estensione per Chrome, un Add-on per Firefox, o un'applicazione desktop utilizzando Electron, NW.js o AppJS (vedi questa risposta per dettagli). Per il supporto delle funzioni di freccia, vedere:

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

• C'è una sintassi ancora più nuova ora chiamata funzioni async con una nuova parola chiave await che invece di questo codice:

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

ti permette di scrivere:

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

Si può usare solo all'interno di una funzione creata con la parola chiave async. Per maggiori informazioni, vedere:

• 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 Per il supporto nei browser, vedere:
• http://caniuse.com/async-functions Per il supporto in Node, vedere:
• http://node.green/#ES2017-features-async-functions In luoghi dove non si ha il supporto nativo per async e await si può usare Babel:
• https://babeljs.io/docs/plugins/transform-async-to-generator/ o con una sintassi leggermente diversa un approccio basato su generatori come in co o Bluebird coroutines:
• https://www.npmjs.com/package/co

• http://bluebirdjs.com/docs/api/promise.coroutine.html Maggiori informazioni

  Alcune altre domande sulle promesse per maggiori dettagli:

• https://stackoverflow.com/questions/40720512/promise-call-separate-from-promise-resolution/40721397#40721397
• Q Promise delay
• Restituire il risultato della promessa invece della promessa
• Esportazione del modulo dal risultato della promessa
• 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
• Perché Promise.all è indefinito
• 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
• Promesse e prestazioni
• Problemi a raschiare due URL con le promesse
• http.request non restituisce dati anche dopo aver specificato return sull'evento '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
• Restituire un valore da una chiamata di funzione prima di completare tutte le operazioni all'interno della funzione stessa?
• 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

L'unico modo per restituire i dati dalla funzione sarebbe fare una chiamata sincrona invece di una chiamata asincrona, ma questo bloccherebbe il browser mentre aspetta la risposta.

Potete passare una funzione di callback che gestisce il risultato:

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

Chiamatela così:

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.

Vedere l'esempio di jquery docs: http://api.jquery.com/jQuery.ajax/ (circa 2/3 della pagina)

Potresti cercare il seguente codice:

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

Stessa pagina... più in basso.