如何将 async/await 与 Promises 结合起来？

Question

In the below code have I createPost() inside an async function, but I don't want to use await on it, so it blocks execution of the rest of the function. That is why I used then .

The outer async function have lots of other functions that use await , so that can't be changed.

Question

Since createPost() is a async / await function (see below). How can it resolve/reject to then / catch in the outer function?

module.exports = async (p) => {
  // lots of code here
  
 const t = await function1();      

    // lots of code here
    createPost(p).then(message => {
      // lots of code here
      console.log("ok " + message);
    }).catch(message => {
      console.log("failed " + message);
    });
};

createPost()

module.exports = async (p) => {
  // lots of code here
  try {
    const r = await getStat();
  } catch (error) {
    console.log(error);
  };
};

Answer 1

async / await is a more modern equivilant to .then / .catch .
In this case you have mixed the syntaxes of both.
You don't need try / catch blocks when using .then ,
just like you don't need to declare a function as async when using the try / catch syntax.

Other than that there's no reason they can't work together in seperate functions.

module.exports = (p) => {
  createPost(p).then(message => {
    console.log("ok " + message);
  }).catch(message => {
    console.log("failed " + message);
  });
};

createPost():

module.exports = async (p) => {
  try {
    const r = await getStat();
  } catch (error) {
    console.log(error);
  };
};

Answer 2

An async decleration on a function is redundant and wrong if you're not using the await keyword inside.

await/async are often referred to as syntactic sugar, and let us wait for something (eg an API call), giving us the illusion that it is synchronous in an actual asynchronous code, which is a great benefit.

The things you want to acheive with async/await is is possible with promises but the advantages of async/await. let's an example with this code:

 const makeRequest = () => //promise way getJSON() .then(data => { return data }) makeRequest(); const makeRequest = async () => { //async await way const data = await getJSON(); return data; } makeRequest()

Why is async/await prefered over promise?

1. Concise and clean - We didn't have to write .then and create an anonymous function to handle the response, or give a name data to a variable that we don't need to use. We also avoided nesting our code. async/await is a lot cleaner.

2. Error handling - Async/await makes it finally possible to handle both synchronous and asynchronous errors with the same try/catch format.

3. Debugging - A really good advantage when using async/await is that it's much easier to debug then promises for 2 reasons: 1) you can't set breakpoints in arrow functions that return expressions (no body). 2) if you set a breakpoint inside a .then block and use debug shortcuts like step-over, the debugger will not move to the the following .then because it only “steps” through synchronous code.

4. Error stacks - The error stack returned from promises chain gives us no idea of where the error occured and can be misleading. async/await gives us the error stack from async/await points to the function that contains the error which is a really big advantage.

Answer 3

"What changes do I need to make to createPost() so I can use then/catch in the outer function?" -

All you need is to do is return a promise in outer function (using new Promise(...) or defer pattern ), And async function always return a new promise, Don't worry about multilayer promises, It will get flatten anyway. (like: await Promise.resolve(Promise.resolve(Promise.resolve("msg"))) -> "msg" )

"How do I specify message that the outer function gets?" - It depend, Depend on when you want to pull it.

This is common in async world. There is a pattern called defer pattern , Lets do an example:

 function deferred() { let methods; const promise = new Promise((resolve, reject) => { methods = { resolve, reject }; }); return Object.assign(promise, methods); } const delay = ms => new Promise(ok => setTimeout(ok, ms)); async function myAsyncFunc() { let defer = deferred(); // create an async function and called immediately, In orther to use await inside... Although you can use `.then` pattern also. (async function () { await delay(2000); console.log("2s passed") defer.resolve("msg") })(); await delay(3000); console.log("3s passed") return defer } myAsyncFunc().then(console.log); // "msg"