blocks|key|4048147|text|调用async函数(这里是analyze)将返回一个promise，它将根据async函数的返回值或是否抛出错误来解决或拒绝。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4048148|现在，analyze函数正在处理抛出的错误，但是当抛出错误时，它将返回一个Promise.reject()。Promise.reject()在这里是未处理的拒绝，这就是日志所描述的。|4048149|就同步函数而言，等效函数为|4048150|function+sync()+{
++try+{
++++//+do+something+dangerous
++}+catch+(ex)+{
++++throw+Error('Something+bad+happened');+//+this+error+is+still+being+thrown+and+nobody+is+handling+it
++}
}|code-block|syntax|javascript|4048151|要处理此错误，可以在调用sync时执行以下操作，将其包装在try+and+catch中|4048152|try+{
++sync();
}+catch+(ex)+{
++console.error(ex);+//+not+gonna+throw+another+exception,+otherwise+the+program+might+crash
}|4048153|现在，analyze函数的此包装的等价物将使用另一个异步函数，或者更好，因为调用async函数将返回Promise，请使用Promise的catch方法|4048154|analyze()
++.then(()+=>+console.log('My+work+is+done+here'))
++.catch(ex+=>+console.error(ex));+//+NOTE:+not+throwing+another+exception|4048155|更好的做法是在一开始就不返回来自catch的拒绝，从而使analyze，|4048156|async+function+analyze(stack,+libraries)+{
++try+{
++++const+config+=+await+buildConfiguration(stack,+libraries);
++++return+await+databaseInsertion(vulnsObject);
++}+catch+(err)+{
++++console.error(err);+//+not+eating+up+good+errors+with+something+vague+is+always+good
++++return+null;+//+or+something+else+to+signify+that+insert+failed
++}
}|4048157|entityMap^0|2|5|D|7|12|5|0|3|7|11|G|1I|G|0|0|0|0|0|3|7|14|5|1E|7|1P|7|1X|5|0|0|G|5|S|7|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1G|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1H|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1J|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|U|3|V|5|L|7|1V|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|1W|8|@$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|L|7|21|8|@]|D|@]|E|$M|N]]|$1|10|3|-4|5|6|7|22|8|@]|D|@]|E|$]]]|11|$]]

Calling an <code>async</code> function (here, <code>analyze</code>) would return a promise, which will resolve or reject according to the return value of the <code>async</code> function or whether an error was thrown.

Now, the <code>analyze</code> function is handling the error thrown but it will return a <code>Promise.reject()</code> when an error is thrown. A <code>Promise.reject()</code> is the unhandled rejection here, which is what the log is stating.

In terms of a synchronous function the equivalent will be

<pre><code>function sync() {
 try {
 // do something dangerous
 } catch (ex) {
 throw Error('Something bad happened'); // this error is still being thrown and nobody is handling it
 }
}
</code></pre>

To handle this error you can do the following when you are calling sync, wrap it in try and catch again

<pre><code>try {
 sync();
} catch (ex) {
 console.error(ex); // not gonna throw another exception, otherwise the program might crash
}
</code></pre>

Now, the equivalent of this wrap for the <code>analyze</code> function will be using another async function, or better since calling <code>async</code> function will return a <code>Promise</code>, use the <code>catch</code> method of a <code>Promise</code>

<pre><code>analyze()
 .then(() =&gt; console.log('My work is done here'))
 .catch(ex =&gt; console.error(ex)); // NOTE: not throwing another exception
</code></pre>

Even better would be to not return a rejection from <code>catch</code> in the first place, thus making <code>analyze</code>,

<pre><code>async function analyze(stack, libraries) {
 try {
 const config = await buildConfiguration(stack, libraries);
 return await databaseInsertion(vulnsObject);
 } catch (err) {
 console.error(err); // not eating up good errors with something vague is always good
 return null; // or something else to signify that insert failed
 }
}
</code></pre>

blocks|key|4048874|text|在使用async-await扫描功能时，您将.then()+.catch()瀑布与await混合在一起。async-await处理承诺的能力和.then()一样好。因此，坚持使用一个流，并尝试在一个函数中混合这两个或在另一个函数中混合这两个流。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4048875|async+foo(req,+res,+next)+{
++++try+{
++++++++await+scan(req.params.stack);
++++++++res.send('ok');
++++}+catch+(err)+{
++++++++res.status(500).send('fail');
++++}
}

async+scan(stack)+{
++try+{
++++const+libs+=+[1,2,3];

++++//+This+libs.map+functions+return+promise.+then+why+not+use+await?
++++const+promises+=+await+libs.map(async+l+=>+analyze(stack,+l);

++++//+Again+q.allSettled+returns+promise,+use+await+here+too
++++let+results+=+await+q.allSettled(promises);

++++const+rejected+=+results.filter(r+=>+r.state+===+'rejected');

++++if+(rejected.length+===+results.length)+throw+new+Error('Failed');

++++return+results;

++}

++//+If+any+promise+call+reject+function+will+be+in+catch
++catch+(err)+{
++++throw+new+Error(err);
++}
}

async+function+analyze(stack,+libraries)+{
++++try+{
++++++++const+config+=+await+buildConfiguration(stack,+libraries);
++++++++return+await+databaseInsertion(vulnsObject);
++++}
++++catch+(err)+{
++++++++console.log(err);
++++++++return+null;
++++}
}|code-block|syntax|javascript|4048876|entityMap^0|3|B|M|7|U|8|15|5|1G|B|1Z|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|L|$]]

While using <code>async-await</code> scan function you were mixing <code>.then()</code> <code>.catch()</code> waterfall with <code>await</code>. <code>async-await</code> handles promises as good as <code>.then()</code>. So stick with one flow and try to mix both in one function or one inside another.

<pre><code>async foo(req, res, next) {
 try {
 await scan(req.params.stack);
 res.send('ok');
 } catch (err) {
 res.status(500).send('fail');
 }
}

async scan(stack) {
 try {
 const libs = [1,2,3];

 // This libs.map functions return promise. then why not use await?
 const promises = await libs.map(async l =&gt; analyze(stack, l);

 // Again q.allSettled returns promise, use await here too
 let results = await q.allSettled(promises);

 const rejected = results.filter(r =&gt; r.state === 'rejected');

 if (rejected.length === results.length) throw new Error('Failed');

 return results;

 }

 // If any promise call reject function will be in catch
 catch (err) {
 throw new Error(err);
 }
}

async function analyze(stack, libraries) {
 try {
 const config = await buildConfiguration(stack, libraries);
 return await databaseInsertion(vulnsObject);
 }
 catch (err) {
 console.log(err);
 return null;
 }
}
</code></pre>

blocks|key|4048233|text|在analyze()中，返回的是Project.reject()，但analyze()是一个异步函数。因此，它会解析您返回的任何值，并拒绝您抛出的任何错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4048234|++++async+function+analyze(stack,+libraries)+{
++++++++try+{
++++++++++++const+config+=+await+buildConfiguration(stack,+libraries);
++++++++++++return+await+databaseInsertion(vulnsObject);
++++++++}+catch+(err)+{
++++++++++++return+Promise.reject('Error+while+trying+to+analyze+libs');
++++++++}
++++}|code-block|syntax|javascript|4048235|因此，当analyze函数捕获到错误时，您正在创建一个拒绝，但随后会解决该函数。所以Promise.reject('Error+while+trying+to+analyze+libs');没有被处理。由于异步函数总是返回一个promise，该promise将解析您返回的所有内容，并拒绝您抛出的任何内容，因此analyze函数将始终解析。试着这样做。|offset|length|style|CODE|4048236|++++async+function+analyze(stack,+libraries)+{
++++++++try+{
++++++++++++const+config+=+await+buildConfiguration(stack,+libraries);
++++++++++++return+await+databaseInsertion(vulnsObject);
++++++++}+catch+(err)+{
++++++++++++throw+Error('Error+while+trying+to+analyze+libs');
++++++++}
++++}|4048237|我在这段代码中看到的另一个可能的问题是，即使你向map(async+func)传递了一个异步函数，它也不关心。它不会等待每个函数完成后才调用下一个函数。|4048238|const+promises+=+libs.map(async+l+=>+analyze(stack,+l)
++++++.catch((err)+=>+{+throw+new+Error(err);+}));
++++return+q.allSettled(promises)
++++++.then((results)+=>+{
++++++++const+rejected+=+results.filter(r+=>+r.state+===+'rejected');
++++++++if+(rejected.length+===+results.length)+throw+new+Error('Failed');
++++++++return+results;
++++++})
++++++.catch((err)+=>+{
++++++++throw+new+Error(err);
++++++});|4048239|下面有两个变化|4048240|const+promises+=+libs.map(async+l+=>+await+analyze(stack,+l)
++++++.catch((err)+=>+{+throw+new+Error(err);+}));
++++return+q.allSettled(+await+promises)
++++++.then((results)+=>+{
++++++++const+rejected+=+results.filter(r+=>+r.state+===+'rejected');
++++++++if+(rejected.length+===+results.length)+throw+new+Error('Failed');
++++++++return+results;
++++++})
++++++.catch((err)+=>+{
++++++++throw+new+Error(err);
++++++});|4048241|我在analyze函数之前添加了一个await，并在将promises变量传递到q.allSettled()之前添加了一个await。|4048242|entityMap^0|0|0|16|1H|0|0|O|F|0|0|0|0|14|E|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1C|8|@$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|Z|$]]

In the analyze() you are returning Project.reject() but analyze() is an async function. Therefor it resolves any value that you return and rejects any error you throw.

<pre><code> async function analyze(stack, libraries) {
 try {
 const config = await buildConfiguration(stack, libraries);
 return await databaseInsertion(vulnsObject);
 } catch (err) {
 return Promise.reject('Error while trying to analyze libs');
 }
 }
</code></pre>

So when the analyze function catches an error you are creating a rejection but then resolving the function. So <code>Promise.reject('Error while trying to analyze libs');</code> is not being handled. Since async functions always return a promise that resolves with whatever you return and rejects whatever you throw, your analyze function is always going to resolve. Try doin this...

<pre><code> async function analyze(stack, libraries) {
 try {
 const config = await buildConfiguration(stack, libraries);
 return await databaseInsertion(vulnsObject);
 } catch (err) {
 throw Error('Error while trying to analyze libs');
 }
 }
</code></pre>

The other thing I see as a possible problem in this code is even though you pass the <code>map(async func)</code> an async function, it doesn't care. It won't wait for each function to complete before calling the next.

<pre><code>const promises = libs.map(async l =&gt; analyze(stack, l)
 .catch((err) =&gt; { throw new Error(err); }));
 return q.allSettled(promises)
 .then((results) =&gt; {
 const rejected = results.filter(r =&gt; r.state === 'rejected');
 if (rejected.length === results.length) throw new Error('Failed');
 return results;
 })
 .catch((err) =&gt; {
 throw new Error(err);
 });
</code></pre>

There are two changes bellow

<pre><code>const promises = libs.map(async l =&gt; await analyze(stack, l)
 .catch((err) =&gt; { throw new Error(err); }));
 return q.allSettled( await promises)
 .then((results) =&gt; {
 const rejected = results.filter(r =&gt; r.state === 'rejected');
 if (rejected.length === results.length) throw new Error('Failed');
 return results;
 })
 .catch((err) =&gt; {
 throw new Error(err);
 });
</code></pre>

I added an await before the analyze function and an await before passing the promises variable into <code>q.allSettled()</code>.

I'm fairly new to async await in javascript so this question might be something I don't know.
I have this
<pre><code> async function foo(req, res, next) {
 try {
 await scan(req.params.stack);
 res.send('ok');
 } catch (err) {
 res.status(500).send('fail');
 }
 }

async function scan(stack) {
 try {
 const libs = [1,2,3];
 const promises = libs.map(async l =&gt; analyze(stack, l)
 .catch((err) =&gt; { throw new Error(err); }));
 return q.allSettled(promises)
 .then((results) =&gt; {
 const rejected = results.filter(r =&gt; r.state === 'rejected');
 if (rejected.length === results.length) throw new Error('Failed');
 return results;
 })
 .catch((err) =&gt; {
 throw new Error(err);
 });
 } catch (err) {
 throw new Error(err);
 }
}

async function analyze(stack, libraries) {
 try {
 const config = await buildConfiguration(stack, libraries);
 return await databaseInsertion(vulnsObject);
 } catch (err) {
 return Promise.reject('Error while trying to analyze libs');
 }
}
</code></pre>
Somehow I'm getting this wild warning and I don't know where I am not catching the error.
Of course, I'm making build configuration fail in order to test the error, but instead of having a normal flow cathing the error I got this:
<pre><code>(node:415) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 3): Error: Error while trying to analyze libs
</code></pre>
Am I using async await good? Is there any pattern I should follow in order to chain async await?
The wild thing is that the foo function works well, meaning that the res.status.(500).send('fail'); works and I'm getting the response
When I was using native promises this error didn't appear.
I'm really stuck here

Unhandle rejection promise async await chain

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我对javascript中的async await比较陌生，所以这个问题可能是我不知道的。我有这个  async function foo(req, res, next) {    try {      await scan(req.params.stack);      res.send('ok');    } ca...

问取消处理拒绝承诺异步等待链
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问取消处理拒绝承诺异步等待链EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问取消处理拒绝承诺异步等待链
EN