Nodejs：一直有个疑问，用 nodejs 时有什么优雅的办法能让代码在流程上回避掉回调吗？
Nodejs：一直有个疑问，用 nodejs 时有什么优雅的办法能让代码在流程上回避掉回调吗？
虽然现在 ES 标准里加上了 async await 来实现同步操作，还有 Promise，但业务复杂了，代码还是会被各种回调弄的执行流程出问题
举个例子
写 js 的时候用的最多的应该就是回调了，回调里可以传很多个参数，简单的操作，这样写很方便，但业务复杂了，就不方便了，回调地狱也就是这样来的
这时候你可能会说不是有 Promise 吗，但用这货我觉得也就是把代码变的好看些，拿结果还是要靠 then 方法回调拿
到这你可能还会说，不是还有 async await 吗，这货确实不用从 then 函数的回调里拿数据了，但用 nodejs 多了就会发现，很多函数的调用的写法还是会用到回调，而且这时候还会在回调函数的前面加上个 async，我也是无语了，这不是又回到起点了吗，如下
it （'waitBody', async function() {
await driver.sleep(500).wait('body', 30000).html().then(function(code) {
isPageError(code).should.be.false;
})
})
当然也有用起来舒服的地方，比如 mongoose 的查询
const results = await UserModel.find({});
综上，难道就没有一个优雅的方法能让代码一行一行的执行吗，前一个结果执行完了，拿到结果再参与下一行代码的执行？
有人会说了，你上面不是说了 async await 了吗，它不就是这样用的吗？那为啥还要在回调的方法上用 async await 呢？总觉得有点换汤不换药，折腾来折腾去，还是离不了回调，但回调又会涉及到代码结构和流程控制上的问题
还请原谅我这小白的问题，相信很多学习 nodejs 的朋友都有过这样的疑惑 😂
这个和 nodejs 有什么关系呢，那异步你怎么解决异步回调的问题？ async 已经很接近同步的写法了。
不是 nodejs 想这么做，而是逻辑上只有这样的处理啊，不断的回调，我知道你什么时候运行什么方法嘛？我只能等你运行完成之后调用我才知道，你可以选择同步，但是问题是同步又阻塞线程你满意嘛。。
另外你用 await 就用错了，是我我会这么用，虽然我接触 await 是在 flutter 里面。
it （‘waitBody’, async function() {
var a = await driver.sleep(500);
var b =await a.wait(‘body’, 30000);
await html();
(function(code) {
isPageError(code).should.be.false;
})();
})
#14 是的，然后你就没必要去不断的 写个 promise.then()去处理回调了，把 promise.then()的东西丢到一个方法里面，一个个 await 调用，实际上会比 promise.then()好看,而且逻辑上清晰。async 没有解决什么根本上的问题，只是一种新的写法让异步回调看起来像同步，把箭头函数里面的东西丢到一个封装方法里面，最后到达一个更直观的代码.
试试这样
const code = await driver.sleep(500).wait(‘body’, 30000).html();
isPageError(code).should.be.false;
回调是不可能避免的，只是封装成 promise，让.then 或者 await 调用而已
.then 和 await 只是为了让代码变得好看
比如
await cb1()
await cb2()
await cb3()
要比
f()
.then(cb1())
.then(cb2())
.then(cb3())
或者
f(cb3(cb2(cb1)))
好看一些
我也是觉得 async await 这种就是让代码好看的，还是没有解决回调问题
----------------------
因为回调本来就不是问题啊，nodejs 的精髓你要把它“解决”掉，那为什么要用 nodejs 呢
ps：async await 可不只是好看一点这么简单。
async 给了你统一的错误流，以及可精确控制范围的 try catch。
没有 async 前，写复杂异步链的异常处理非常之痛苦……
#6 大佬，再打扰一下，看你给的链接里的介绍，fs.stat 方法传进 util.promisify(fs.stat) 里当参数后，下面就可以直接使用 async/await 来同步执行拿返回值数据了，当然它们有规则，就是 fs.stat 方法的回调第一个参数要是异常
这样看来我是不是就可以理解为，任何一个被包装成了 Promise 的函数都可以使用 async/await 来同步执行拿返回值的数据？
另外 util.promisify() 方法跟自定义的 Promise 封装是不是效果一样的呢？比如下面这两种用法是等效的吗？js<br>function timeout(ms) {<br> return new Promise((resolve, reject) => {<br> setTimeout(resolve, ms, 'done');<br> });<br>}<br><br>timeout(100).then((value) => {<br> console.log(value);<br>});<br>js<br>const timeout = util.promisify(setTimeout);<br>timeout(100).then((value) => {<br> console.log(value);<br>});<br>
谢谢！
js<br><br>function timeout(ms) {<br> return new Promise((resolve, reject) => {<br> setTimeout(resolve, ms);<br> });<br>}<br><br>await timeout(1000);<br><br>
这就是 nodejs 的特点…如果没有异步，单线程模型就无法支持多用户访问了。
某些模块的 api 还是支持同步调用的，比如 fs.readFileSync…写起来方便但是就阻塞了
代码清楚就行了，async/await 只是语法糖，不用太敏感
await 之后的代码逻辑上已经是被 await 的 promise 的 then 的 callback，只是看起来代码是“连续”的
"任何一个被包装成了 Promise 的函数都可以使用 async/await 来同步执行拿返回值的数据？"
await 期待的就是一个 promise
(如果 await 后面跟的是一个普通的 function, 也不会报错, 只是 await 变得毫无意义了)
顶楼的代码是不是也可以写成<br>const code = await driver.sleep(500).wait('body', 30000).html();<br>isPageError(code).should.be.false;<br>
? 这样会清楚点吗？
这段代码用回调写写看，就知道 await 是不是好看了
for (let i = 0; i < 10; i++) {
const ret = await $.getData(i);
if (ret.code !== 0) {
continue;
}
if (await check(ret.data) === true) {
return ret.data;
}
}
await 一个不 thenable 的表达式也是有作用的，await 后的代码一定在栈清空后才被执行 (和 promise 的 then 同样保证)
考虑:<br>async function foo() {<br> console.log(1);<br> await 0;<br> console.log(3);<br>}<br><br>foo();<br>console.log(2);<br>
是不是有"意义"这个自己判断吧
回调的另一个问题是这个语法不自带 “可组合性”，表现为层数多起来就很难连异常处理一起写对
而 await 时 promise fulfill 天然映射到表达式求值，promise reject 天然映射到求值中 throw，没被 catch 的 reject 会自动向上传递到一个无法忽略的地方
回调函数的循环控制嘛，这个在没有 await 的时候又不是没有
实际上 await 后面是一个 promise 对象，而 promise 对象要返回值给上层需要一个 resolve()作为回调函数，最终还是回调函数
这段程序要是没理解错的话，是需要依次获取数据直到得到正确结果
可以构造一个对象，包含当前执行到的位置(i)，最多可以达到的位置(10)，函数 f(this.i)，每次 f 执行之后 this.i++或者 cb(ret.data)
不要把 async/await 当成同步。。它们只是看起来同步，实际上还是异步，异步逻辑不会消失，只会看起来变得优雅。把 async/await 当成同步那会给自己挖坑的。。
手动维护一个 context 心智负担太重，这只是一个简单的例子，循环可以有多层，调用链路可以有十几层，实际逻辑可能复杂的多，相当于人肉维护一个状态机。同步写法，思路顺畅许多，也更不容易出错。
不仅是 js，各种语言都在往弃回调，引入同步写法。
#46 也就是说用了 async/await 代码会在 await 那地方等着执行完对吧，至于被调用方法执行是同步执行还是异步执行的，不是 async/await 管的了，是这个意思不？
<br>function some (callback){<br>}<br><br>function callback(callback2){<br>}<br><br>function callback2(callback3){<br>}<br>...<br><br><br>
如果执意使用回调函数的思想来设计程序的话，用什么语言都会有这个问题。
JS 是可以完全不用回调函数来设计数据流的，你都用 async await 了，为什么还要用回调函数来传递数据？可以拿出几个例子来，一定有更好的代码的组织方案的。
it （‘waitBody’, async function() {
const code = await driver.sleep(500).wait(‘body’, 30000).html();
isPageError(code).should.be.false;
})
这块没必要再用 then 了，你都用 await 了，那就一定是等着这段代码执行完再执行下一句。
说 python 快我还信了，普通 js 真的不行，npm 装个包都不知道要多久，一升级就各种瞎改，异步也不好写，异常链+正常链+多线程都难搞死了，维护别人代码都想砍人
关于 promiseFunc.then(some_stuff)的观感问题，你可以
Promise.resolve()
.then(stuff_1)
.then(stuff_2)
//…
#58 协程不就是 async/await 吗
其实 NodeJS （ Python 的也是）的 async/await 就是把异步变成协程写法。
——
#70 yarn，请
——
其实异步除了回调、Promise/Future、async/await （包括协程）还有一种就是信号式。
信号式其实多线程下也能很好用，调用链清晰，程序本身就是个系统设计图。
缺点就是状态不能自然保留和共享（必然手动维护 context ），并且对一本道的代码没特别大的影响。
就你给的代码，你不想写 then 回调，
直接:
code = await。。。。
if (判断 code ）。。。
这不就是同步写法吗，await 的优势就是能让你这么写啊，你又不用
我个人就很喜欢写回调套回调，当发现回调卡死了写不下去时候比如 fs.statu 与 fs.read 的配套操作的时候，问题出在了整个处理流程的设计，反过头重新设计就是了。
当然我理解“回调地狱”，，，但我对 Promise、async/await 就感到特别头疼，总是想不起来这个对象怎么用，真希望能尊重下像我这种习惯写回调而不习惯新语法的。
nodejs 就是 IO 类 API 是与主线程分开的另一个线程（其本身是不是队列结构实在是忘了），所以这里姑且认为至少有两个线程，代码顺序的主线程和 IO 类 API 所在那个线程。Promise 之类折腾来去无非是换了个写法而已（从程序员的层面来看）。
在 Node.js 中，确实存在多种优雅的方法来避免回调地狱（callback hell），使代码更加清晰和易于维护。以下是几种常见的方法：
-
Promises： Promises 提供了一种更优雅的方式来处理异步操作。它们允许你使用
.then()和.catch()方法来链式调用，从而避免深度嵌套的回调。function asyncOperation1() { return new Promise((resolve, reject) => { // 模拟异步操作 setTimeout(() => resolve('Result 1'), 1000); }); } asyncOperation1() .then(result1 => { console.log(result1); return asyncOperation2(); // 另一个异步操作 }) .then(result2 => { console.log(result2); }) .catch(error => { console.error(error); }); -
Async/Await： Async/Await 是基于 Promises 的语法糖，使异步代码看起来更像是同步代码，进一步提升了可读性。
async function fetchData() { try { const result1 = await asyncOperation1(); console.log(result1); const result2 = await asyncOperation2(); console.log(result2); } catch (error) { console.error(error); } } fetchData();
通过使用 Promises 和 Async/Await，你可以显著简化 Node.js 中的异步代码，使其更加优雅和易于管理。
