如何从异步调用返回响应

信诺哥

我有一个foo发出异步请求的函数。如何从 返回响应/结果foo？
8 O2 J6 s' T1 l- R& y, j我试图从回调中返回值，并将结果分配给函数内部的一个局部变量并返回那个，但是这些方法都没有真正返回响应（它们都返回undefined或变量的初始值result是）。
# j5 r/ T6 h7 J' S接受回调的异步函数示例（使用 jQuery 的ajax函数）

• function foo() {
  2 j8 [) T% B8 Z& ]8 k4 Z
•     var result;
  
•     $.ajax({
  : m1 O: [& x/ z" l; ~% I
•         url: '...',
    [/ h& j$ {' c1 p9 W, L
•         success: function(response) {
  7 d; W+ j) t' H; b% V8 y5 H& [- ^
•             result = response;
  & \( n7 I& ]8 n% ]( R- n6 V
•             // return response; // 使用 Node.js 的示例：
  5 n+ J& M# `: S4 F
• [code]function foo() {
  
•     var result;
  
•     fs.readFile("path/to/file", function(err, data) {
  * W6 N: x6 _- l+ ?
•         result = data;
  $ k" g+ P  r) ^4 k! ]/ A
•         // return data; // 使用then承诺块的示例：
  ( K" y" h  {8 X5 n3 Q, K1 a: g- [
• [code]function foo() {
  
•     var result;
  * Z2 `( V$ A9 s; y
•     fetch(url).then(function(response) {
  5 m* V- h/ ?; j
•         result = response;
  
•         // return response; // 问题
  
• 在一中的Ajax代表异步。这意味着发送请求（或者更确切地说是接收响应）已经脱离了正常的执行流程。在您的示例中，$.ajax立即返回，并且在return result;您作为success回调传递的函数甚至被调用之前执行下一条语句。
  8 `0 w! d0 ]1 O6 d+ u) I! T! `
• 这是一个类比，希望可以更清楚地区分同步流和异步流之间的区别：
  ; c- n' w0 y3 g" g- B$ Z8 y1 U! p2 g
• 同步
  6 W3 P0 Z' z7 z+ @
• 想象一下，你给朋友打电话，让他帮你查点东西。虽然这可能需要一段时间，但您会等待电话并凝视太空，直到您的朋友给您所需的答案。
  7 \+ A) x0 i9 t
• 当您进行包含“正常”代码的函数调用时，也会发生同样的情况：
  & p6 j; j6 ]/ E8 I9 b3 G/ w
• [code]function findItem() {
  4 H$ Q0 T% ^& T% a" h! O
•     var item;
  ( W4 J0 O# m: m* @
•     while(item_not_found) {
  % s8 F% u* ?  {% b  h
•         // search
  
•     }
  0 Q; V) P: _! C" B
•     return item;
  
• }
  & Q+ j. P; H! Q* _
• var item = findItem();
  
• // Do something with item
  - W/ J; H  Z' Q! X
• doSomethingElse();
  & q2 }1 e3 l7 N0 l! y

尽管findItem可能需要很长时间才能执行，但之后的任何代码var item = findItem();都必须等到函数返回结果。
异步
出于同样的原因，您再次致电您的朋友。但这一次你告诉他你有急事，他应该用你的手机给你回电。你挂断电话，离开家，做你计划做的任何事情。一旦你的朋友给你回电，你就在处理他给你的信息。
5 }) G  S, `5 Z0 l! O6 Y这正是您执行 Ajax 请求时发生的情况。
! x1 o$ _7 ~6 g+ \  b

2 ^. c  N: c" v/ |! v3 Q
• findItem(function(item) {
  9 E3 n* B1 j" n/ [. ?. I
•     // Do something with the item
  - l! v8 R, y, q
• });
  
• doSomethingElse();
  . S7 A0 \' j  @' `/ W% T. c$ m

不是等待响应，而是立即继续执行并执行 Ajax 调用之后的语句。为了得到响应，最终，你提供了一次收到答复要调用的函数，一个回调（注意些什么呢？回电？）。在调用回调之前执行该调用之后的任何语句。
2 G$ k6 O  R+ C) ?9 @/ L: v$ u
解决方案
& t: H: g" R: s  m7 ^3 L拥抱 JavaScript 的异步特性！虽然某些异步操作提供同步对应物（“Ajax”也是如此），但通常不鼓励使用它们，尤其是在浏览器上下文中。
( @/ L: X) k- \& E你问为什么不好？
. L$ S) l7 k8 E7 P, N* F$ h/ X# hJavaScript 在浏览器的 UI 线程中运行，任何长时间运行的进程都会锁定 UI，使其无响应。另外，JavaScript 的执行时间有上限，浏览器会询问用户是否继续执行。
所有这些都会导致非常糟糕的用户体验。用户将无法判断是否一切正常。此外，对于连接速度较慢的用户，效果会更差。
在下文中，我们将研究三种不同的解决方案，它们都建立在彼此之上：
! K. a! r9 a. QPromises withasync/await（ES2017+，如果您使用转译器或再生器，则在旧浏览器中可用）
+ ~0 B! L* m; j! _) M" L, {2 H6 H回调（在节点中流行）
Promises withthen()（ES2015+，如果您使用众多 Promise 库之一，则可在旧浏览器中使用）
6 U* c; a1 V; T# d! M- S( I* E
所有这三个都在当前浏览器和节点 7+ 中可用。

ES2017+：承诺 `async/await
2017 年发布的 ECMAScript 版本引入了对异步函数的语法级支持。的帮助下async和await，你可以写在“同步式”异步的。代码仍然是异步的，但更容易阅读/理解。
async/await建立在承诺之上：一个async函数总是返回一个承诺。await“解开”一个promise 并且要么导致promise 被解决的值，要么在promise 被拒绝时抛出一个错误。
重要提示：您只能await在async函数内部使用。目前，await尚不支持顶级，因此您可能需要创建一个异步 IIFE（立即调用函数表达式）来启动async上下文。
" o& Y/ I/ W6 R! [你可以阅读更多关于async和await的MDN。
+ \) {4 C- X( [. [这是一个详细说明上述延迟功能的示例findItem()：
. j3 {3 X( Q8 y  W- l  d2 g$ q3 l, S1 k

• // Using 'superagent' which will return a promise.
  # Z4 q- J8 Q" ]  V% X/ ~. e
• var superagent = require('superagent')
  
• // This is isn't declared as `async` because it already returns a promise
  
• function delay() {
  , V, a0 H, M8 Y
•   // `delay` returns a promise
  6 T) K" f+ |( Y9 `, I% S
•   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
  + w- k+ g: I+ h5 W2 [: d# e
•     }, 3000);
  
•   });
  
• }
  $ }# o  P3 V: U8 @8 i+ y
• async function getAllBooks() {
  9 ~1 U! H* {$ T; W! a- b3 B" t4 \
•   try {
  
•     // GET a list of book IDs of the current user
  
•     var bookIDs = await superagent.get('/user/books');
  
•     // wait for 3 seconds (just for the sake of this example)
  
•     await delay();
    x3 n* B' \- }' W0 ^
•     // GET information about each book
  / ~% N) V/ P: @2 ]! x
•     return await superagent.get('/books/ids='+JSON.stringify(bookIDs));
  : Z( k- |7 {/ `" W  g
•   } catch(error) {
  
•     // If any of the awaited promises was rejected, this catch block
  5 ^2 y. S* a9 c& Q, r1 \* Q
•     // would catch the rejection reason
  
•     return null;
  6 p: G% G" }( `) Y+ o8 M, C( _' W
•   }
  " n* Z# W- n$ i! D) g8 m7 s
• }
  
• // Start an IIFE to use `await` at the top level
  
• (async function(){
  
•   let books = await getAllBooks();
  
•   console.log(books);
  
• })();
  # y" q, m. ^+ n- K5 b. ~8 w% ~7 a+ V

当前浏览器和节点版本支持async/await. 您还可以通过在regenerator（或使用 regenerator 的工具，例如Babel）的帮助下将代码转换为 ES5 来支持旧环境。

让函数接受回调
7 t7 z3 }; F" J' w回调是指将函数 1 传递给函数 2 时。函数 2 可以在准备好时调用函数 1。在异步进程的上下文中，只要异步进程完成，就会调用回调。通常，结果传递给回调。
在问题的示例中，您可以foo接受回调并将其用作success回调。所以这

3 H/ S+ \6 ]: ^; \( I
• var result = foo();
  
• // Code that depends on 'result'
  

变成
. [3 A9 Z2 W. @$ y- I, I) I

• foo(function(result) {
  
•     // Code that depends on 'result'
  
• });
  + _' U6 {$ Z% `. s/ j8 t% [

这里我们定义了“内联”函数，但您可以传递任何函数引用：
) y3 O+ m% J% v1 v/ @% C

• function myCallback(result) {
  : ~. e" a& y- c7 h
•     // Code that depends on 'result'
  1 i. z0 x$ U, ~5 @
• }
  
• foo(myCallback);
  2 R  K- x; [+ f/ B9 _8 d' ^4 k( J, c

! M1 P' v! _- S# T, x! |foo 本身定义如下：
0 u" R- {1 f8 _: H; h' u& \- ?3 H

• function foo(callback) {
  / x$ K/ x+ l* G* i
•     $.ajax({
  
•         // ...
  
•         success: callback
  . y; r& ^, D8 s% ~' B
•     });
  
• }
  4 E- F6 G% x: ~! \! F5 E+ w

callback将引用foo我们调用时传递给的函数并将其传递给success. 即一旦 Ajax 请求成功，$.ajax将调用callback并将响应传递给回调（可以用 引用result，因为这是我们定义回调的方式）。
7 g* K2 y2 G( u& E( b您还可以在将响应传递给回调之前对其进行处理：
  Q* @5 Y3 u' [, F2 c+ ?6 L

• function foo(callback) {
  ! }; @: B9 U2 O& C8 y
•     $.ajax({
  
•         // ...
  
•         success: function(response) {
  3 p* A: b, R. b8 Y  Y+ \# @
•             // For example, filter the response
  4 c: u3 K) J  d" X6 i; P
•             callback(filtered_response);
  
•         }
  $ P' T& P& Z& g: Y& L/ @
•     });
  
• }
  

使用回调编写代码比看起来更容易。毕竟，浏览器中的 JavaScript 是高度事件驱动的（DOM 事件）。接收 Ajax 响应只不过是一个事件。当您必须使用第三方代码时，可能会出现困难，但大多数问题都可以通过考虑应用程序流程来解决。
& U( l3 t3 D4 k0 d3 h2 x
( A& Y2 m: [4 K: ~ES2015+：使用then() 进行
* h/ Q! W) Q/ v' M该承诺API是ECMAScript的6（ES2015）的新功能，但它有很好的浏览器支持了。还有许多库实现了标准的 Promises API，并提供了额外的方法来简化异步函数的使用和组合（例如，bluebird）。
, f/ F0 {$ y; f- W) H2 }1 ?- G承诺是未来价值的容器。当 promise 收到值（已解决）或被取消（拒绝）时，它会通知所有想要访问此值的“侦听器”。
- o; h& V$ _7 e2 _- o2 j, }与普通回调相比的优势在于它们允许您解耦您的代码并且它们更容易组合。
下面是一个使用 promise 的例子：

+ h) D8 ^' \& W# K+ @; a
• function delay() {
  3 ~, X. i, O" ^0 K6 ?
•   // `delay` returns a promise
  
•   return new Promise(function(resolve, reject) {
  + J# S$ |& a& _& ^/ B9 v( \( K9 m+ f
•     // Only `delay` is able to resolve or reject the promise
  
•     setTimeout(function() {
  . t( T6 E5 V* J; D6 Q5 f1 e0 T
•       resolve(42); // After 3 seconds, resolve the promise with value 42
  & U3 g4 Z' J( Q& _
•     }, 3000);
  ' r/ u5 b# ?) b2 m& E
•   });
  
• }
  
• delay()
  ( K  V% `4 k7 U, g5 Z7 R0 I5 s- ?
•   .then(function(v) { // `delay` returns a promise
  4 a) O$ d$ i; a5 `' `
•     console.log(v); // Log the value once it is resolved
  : D! B7 @8 K5 {3 {. Z6 @
•   })
  
•   .catch(function(v) {
  ) {% A. I- H" l% @; E
•     // Or do something else if it is rejected
  
•     // (it would not happen in this example, since `reject` is not called).
  
•   });
  
• .as-console-wrapper { max-height: 100% !important; top: 0; }
  % @. t0 i6 R1 y7 W

; R) p- ^! Q. A* w' I运行代码片段
展开片段
应用于我们的 Ajax 调用，我们可以使用这样的承诺：

8 ^8 F$ e7 U0 y7 F
• function ajax(url) {
  
•   return new Promise(function(resolve, reject) {
  7 ~4 O# X5 N$ a1 P. V) g
•     var xhr = new XMLHttpRequest();
  : y5 k; \9 S" y: ~2 P: x1 U
•     xhr.onload = function() {
  4 j$ C; Q+ _* c+ U
•       resolve(this.responseText);
  & Y; H( v; N8 v9 D" v" _! q
•     };
  
•     xhr.onerror = reject;
  4 a2 g' O% E7 E& O7 w, n- S% {
•     xhr.open('GET', url);
  * n$ k$ o/ Y3 x% s7 V
•     xhr.send();
  
•   });
  $ c8 ]9 S% ?- G. o3 u9 w: e
• }
    y6 @. J$ b, t& F
• ajax("https://jsonplaceholder.typicode.com/todos/1")
  - @- h& `) h9 m% v& [9 h
•   .then(function(result) {
  + p$ M2 u+ e5 W
•     console.log(result); // Code depending on result
  
•   })
    h5 a8 C$ _& p0 \/ `! ?4 _
•   .catch(function() {
  
•     // An error occurred
  2 m5 e) U' I7 \( B/ w$ k- Z
•   });
  1 j" W/ T9 a# w! c6 Y$ y% f
• .as-console-wrapper { max-height: 100% !important; top: 0; }
  

运行代码片段
' s) \8 I1 H8 y; h. k展开片段
描述 promise 提供的所有优势超出了本答案的范围，但是如果您编写新代码，则应该认真考虑它们。它们为您的代码提供了很好的抽象和分离。
5 p/ v0 G# v& x, a旁注：jQuery 的延迟对象
延迟对象是 jQuery 的自定义承诺实现（在 Promise API 标准化之前）。它们的行为几乎与 Promise 类似，但公开的 API 略有不同。
$ E7 y0 W. Y' ?6 FjQuery 的每个 Ajax 方法都已经返回一个“延迟对象”（实际上是一个延迟对象的承诺），您可以从您的函数中返回它：
5 F) B+ u9 G. Z2 ?2 _

/ G0 ?7 Y, l1 `0 `6 a
• function ajax() {
  ' D8 y% z. @) W' p+ ?( w
•     return $.ajax(...);
  - H3 l( m# D6 A  u9 J
• }
  : [/ u' x/ W; @
• ajax().done(function(result) {
  ( [: u( I0 J$ ^. ]' y% C
•     // Code depending on result
  
• }).fail(function() {
  ) c) l8 B5 J" A
•     // An error occurred
  
• });
  

4 q2 P" R5 M: M, `" E4 I/ U9 a旁注：承诺陷阱
$ I% l, f  \; j: C2 w请记住，promise 和 deferred 对象只是未来值的容器，它们不是值本身。例如，假设您有以下内容：
% r- ?- u# `! {7 P

• function checkPassword() {
  
•     return $.ajax({
  
•         url: '/password',
  
•         data: {
  
•             username: $('#username').val(),
  6 {: M' H7 v  R
•             password: $('#password').val()
  4 @. g! {- q& X) T' l) [( w
•         },
  : F8 e: |( V0 ?( f, |. \' x
•         type: 'POST',
  / C$ `! w0 I1 M
•         dataType: 'json'
  2 {) W5 N+ e  i8 \$ [
•     });
  - ^- e) p6 E4 I# k
• }
  6 T6 E- L, l+ A: R0 A" o
• if (checkPassword()) {
  , }) H3 a+ U2 J* ?+ N
•     // Tell the user they're logged in
  
• }
  

- }7 t6 W4 H/ i+ d: L这段代码误解了上述异步问题。具体来说，$.ajax()在检查服务器上的“/password”页面时不会冻结代码 - 它向服务器发送请求，并在等待时立即返回一个 jQuery Ajax Deferred 对象，而不是来自服务器的响应。这意味着该if语句将始终获取此 Deferred 对象，将其视为true，并像用户登录一样继续。不好。
但修复很简单：

• checkPassword()
  
• .done(function(r) {
  $ h2 a* S( ]9 A  k
•     if (r) {
  
•         // Tell the user they're logged in
  * g2 ^6 Y9 U* w- y; s+ ]
•     } else {
  
•         // Tell the user their password was bad
  7 B4 D, ?/ H5 |( y
•     }
  
• })
  
• .fail(function(x) {
  # X; H! y0 T. `5 E6 ?
•     // Tell the user something bad happened
  8 _  {. Z, W; D8 U4 |) j* ^) u1 v
• });
  . {7 z! X7 V9 ^

不推荐：同步“Ajax”调用
正如我所提到的，一些（！）异步操作具有同步对应物。我不提倡使用它们，但为了完整起见，以下是执行同步调用的方式：
: Q: f6 B, }1 g# v, z6 m没有 jQuery
如果您直接使用XMLHttpRequest对象，请将其false作为第三个参数传递给.open.
jQuery
如果您使用jQuery，则可以将该async选项设置为false. 请注意，此选项自 jQuery 1.8 起已弃用。然后，您仍然可以使用success回调或访问jqXHR 对象的responseText属性：
6 n1 }' L& M, E* U: E8 I. M

• function foo() {
  
•     var jqXHR = $.ajax({
  
•         //...
  * H! P1 D( ]8 G" a5 ]' y( f
•         async: false
  % Q- p2 y# K! f3 n, T8 N
•     });
  ! `- S1 G$ U% C
•     return jqXHR.responseText;
  
• }
  

如果使用任何其他的jQuery的Ajax的方法，例如$.get，$.getJSON等等，必须将其改为$.ajax（因为你只能传递配置参数$.ajax）。
: h, J' x1 r  L当心！无法进行同步JSONP请求。JSONP 就其本质而言始终是异步的（甚至不考虑此选项的另一个原因）。