Note: Esta resposta foi escrita em fevereiro de 2010.
Ver atualizações de 2015, 2016 e 2017 na parte inferior. Você pode'não devolver nada de uma função que seja assíncrona. O que você pode retornar é um promisso. Expliquei como funcionam as promessas em jQuery nas minhas respostas a essas perguntas:

• função JavaScript que retorna dados de chamada AJAX
• jQuery jqXHR - cancelar chamadas encadeadas, acionar cadeia de erros Se você pudesse explicar por que você quer devolver os dados e o que você quer fazer com eles mais tarde, então eu poderia ser capaz de lhe dar uma resposta mais específica como fazê-lo. Geralmente, em vez de:

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

você pode escrever a sua função testeAjax assim:

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

Então podes ter a tua promessa assim:

var promise = testAjax();

Você pode armazenar sua promessa, você pode passá-la, você pode usá-la como argumento em chamadas de função e você pode devolvê-la de funções, mas quando você finalmente quer usar seus dados que são devolvidos pela chamada AJAX, você tem que fazer assim:

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

(Ver actualizações abaixo para uma sintaxe simplificada.) Se os seus dados estiverem disponíveis neste momento, então esta função será imediatamente invocada. Se for't então ela será invocada assim que os dados estiverem disponíveis. O objetivo de fazer tudo isso é que seus dados não estejam disponíveis imediatamente após a chamada para $.ajax porque eles são assíncronos. Promessas é uma boa abstração para funções a dizer: Eu posso'não lhe devolver os dados porque eu não'ainda não os tenho e eu não'não quero bloquear e fazê-lo esperar por isso aqui'é uma prometida em vez disso e você'será capaz de usá-los mais tarde, ou simplesmente dá-lo a outra pessoa e acabar com ele. Veja isto [**DEMO***](http://jsfiddle.net/jW68r/). ATUALIZAÇÃO (2015)

Atualmente (a partir de março de 2015) jQuery Promises não são compatíveis com a especificação Promises/A+, o que significa que podem não cooperar muito bem com outras implementações em conformidade com Promises/A+. Entretanto, jQuery Promises na próxima versão 3.x ** será compatível com a especificação Promises/A+ (graças a Benjamin Gruenbaum por tê-la apontado). Atualmente (a partir de maio de 2015) as versões estáveis de jQuery são 1.x e 2.x.

O que expliquei acima (em março de 2011) é uma forma de usar jQuery Deferred Objects para fazer algo de forma assíncrona que em código síncrono seria alcançado através da devolução de um valor. Mas uma chamada de função síncrona pode fazer duas coisas - ela pode retornar um valor (se puder) ou lançar uma exceção (se puder't retornar um valor). Promises/A+ aborda ambos os casos de uso de uma forma que é tão poderosa quanto o tratamento de exceções em código síncrono. A versão jQuery lida com o equivalente a retornar um valor muito bom, mas o equivalente a um complexo tratamento de exceções é um pouco problemático. Em particular, o ponto completo do tratamento de exceções em código síncrono não é apenas desistir com uma boa mensagem, mas tentar consertar o problema e continuar a execução, ou possivelmente lançar novamente a mesma ou uma exceção diferente para algumas outras partes do programa para tratar. Em código síncrono, você tem uma pilha de chamadas. Em chamadas assíncronas você não't e o tratamento avançado de exceções dentro das suas promessas, como requerido pela especificação Promises/A+, pode realmente ajudá-lo a escrever código que irá tratar de erros e exceções de uma forma significativa, mesmo para casos de uso complexo. Para diferenças entre jQuery e outras implementações, e como converter promessas jQuery para Promessas/A+, veja Vindo de jQuery por Kris Kowal et al. no wiki da biblioteca Q e Promessas chegam em JavaScript por Jake Archibald em HTML5 Rocks.

Como devolver uma promessa real

A função do meu exemplo acima:

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

retorna um objeto jqXHR, que é um jQuery Objeto Diferido. Para fazê-lo retornar uma promessa real, você pode mudá-lo para - usando o método do wiki Q:

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

ou, usando [o método do artigo HTML5 Rocks] (http://www.html5rocks.com/en/tutorials/es6/promises/#toc-javascript-promises):

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

Este Promise.resolve($.ajax(...)) é também o que é explicado na documentação do módulo promise e deve funcionar com ES6 Promise.resolve(). Para utilizar o ES6 Promises hoje você pode utilizar [es6-promise module's polyfill()] `](https://github.com/jakearchibald/es6-promise#auto-polyfill) por Jake Archibald. Para ver onde você pode utilizar o ES6 Promises sem o polifill, veja: Posso utilizar: Promises. Para mais informações, veja:

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

  Futuro da jQuery

  As futuras versões de jQuery (a partir da 3.x - as versões estáveis atuais a partir de maio de 2015 são 1.x e 2.x) serão compatíveis com a Promessas/A+ especificação (graças a Benjamin Gruenbaum por indicá-lo nos comentários). "Duas mudanças que nós'já decidimos são a compatibilidade Promessa/A+ para nossa implementação diferida [...]" (jQuery 3.0 e o futuro do desenvolvimento Web). Para mais informações, veja: jQuery 3.0: The Next Generations por Dave Methvin e jQuery 3.0: Mais interoperabilidade, menos Internet Explorer por Paul Krill.

  Conversas interessantes

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

• [JavaScript Promises](https://youtu.be/oa2clhsYIDY) por David M. Lee (Nodevember 2014) ACTUALIZAÇÃO (2016)

  Há uma nova sintaxe em ECMA-262, 6ª Edição, Seção 14.2 chamada funções de seta que pode ser usada para simplificar ainda mais os exemplos acima. Usando a API jQuery, em vez de:

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

você pode escrever:

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

ou utilizando a API Promises/A+:

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

Lembre-se de usar sempre manipuladores de rejeição com:

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

ou com:

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

Veja esta resposta para ver por que você deve sempre usar os manipuladores de rejeição com promessas:

• https://stackoverflow.com/questions/40920179/should-i-refrain-from-handling-promise-rejection-asynchronously/40921505#40921505 É claro que neste exemplo você poderia usar apenas promise.then(alert) porque você'está apenas chamando alert com os mesmos argumentos da sua chamada de retorno, mas a sintaxe da seta é mais geral e permite que você escreva coisas como:

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

Nem todo navegador suporta essa sintaxe ainda, mas há certos casos em que você'tem certeza de qual navegador seu código será executado - por exemplo, ao escrever uma extensão Chrome, um Firefox Add-on, ou uma aplicação desktop usando Electron, NW.js ou AppJS (veja esta resposta para detalhes). Para o suporte às funções de seta, veja:

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

• Há uma sintaxe ainda mais nova neste momento chamada funções async com uma nova palavra-chave `await' que, em vez deste código:

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

deixa-te escrever:

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

Você só pode utilizá-lo dentro de uma função criada com a palavra-chave async. Para mais informações, veja:

• 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 Para suporte em navegadores, veja:
• http://caniuse.com/async-functions Para suporte no Node, veja:
• http://node.green/#ES2017-features-async-functions Em lugares onde você não'não tem suporte nativo para async e await você pode usar Babel:
• https://babeljs.io/docs/plugins/transform-async-to-generator/ ou com uma sintaxe ligeiramente diferente, uma abordagem baseada em gerador, como em "co" ou "Bluebird coroutines":
• https://www.npmjs.com/package/co

• http://bluebirdjs.com/docs/api/promise.coroutine.html Mais informações

  Algumas outras perguntas sobre promessas para mais detalhes:

• https://stackoverflow.com/questions/40720512/promise-call-separate-from-promise-resolution/40721397#40721397
• Q Promise delay
• Return Promise resultado em vez de Promise
• Exportar módulo a partir do resultado prometido
• 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
• Por que Promise.all é indefinido
• 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
• Promessas e desempenho
• Problema ao raspar duas URLs com promessas
• http.request não retornar dados mesmo depois de especificar retorno no '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
• Devolver um valor de uma chamada de função antes de completar todas as operações dentro da própria função?
• 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

A única maneira de retornar os dados da função seria fazer uma chamada síncrona em vez de uma chamada assíncrona, mas isso congelaria o navegador enquanto ele's espera pela resposta.

Você pode passar em uma função de callback que trata do resultado:

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

Chama-lhe assim:

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.

Veja o exemplo da Jquery Docs: http://api.jquery.com/jQuery.ajax/ (cerca de 2/3 da página)

Você pode estar à procura do seguinte código:

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

A mesma página...mais para baixo.