Javascript Node JS:不调用promise reject（）回调将停止程序的执行

我似乎误解了承诺机制。在以下代码中：

async function CreateSession()
{
      var sessionId = await new Promise((resolve, reject) => {
        request(options, function (error, response, body) {
            if (!error && response.statusCode == 200) {
                log.debug("Session created successfully")
                resolve(body["session-id"]);
            }
            else
            {
                log.error("Failed to create session:");
                log.error(error);
                // reject(error);
            }
        });
    });

    log.debug(`Session Id: ${sessionId}`);
    return sessionId;
}

注释reject（）是为了理解该机制。 按如下方式调用上述CreateSession（）函数并确保发生错误时：

async function MyFunction()
{
    var sessionId = await CreateSession();
    AnotherCode();
}

整个程序停止，CreateSession中wait之后的代码永远不会到达，也永远不会调用另一个code（），即使我为uncaught异常放置了一个处理程序，它也不会捕获任何错误

我的问题是:

• 为什么程序在未调用reject（）时停止
• 如果这是一个错误，为什么处理程序没有为未捕获的异常调用它
• 当承诺无法运行其代码时，如何忽略错误

为什么程序在未调用reject（）时停止

因为

等待

。程序将等待

解决

或

拒绝

的承诺。它无法以某种方式检测到promise构造函数中的代码已经完成执行（即使可以——什么是“标准”行为？），并且没有更多的代码

从：

异步函数可以包含一个等待表达式，该表达式暂停异步函数的执行以等待传递的承诺的解析，然后恢复异步函数的执行并作为解析值进行计算

对于一些“幕后”的见解，您可能想看看由Babel之类的Transpiler生成的ES5代码（IIRC它使用生成器来处理这个问题）

如果这是一个错误，为什么处理程序没有为未捕获的异常调用它

如果未使用

reject

抛出或传递

error，则程序不知道
error
是错误

当承诺无法运行其代码时，如何忽略错误

解析
（而不是
拒绝
）或
拒绝
，然后围绕
等待
代码执行经典的try/catch

为什么程序在未调用reject（）时停止

因为
等待
。程序将等待
解决
或
拒绝
的承诺。它无法以某种方式检测到promise构造函数中的代码已经完成执行（即使可以——什么是“标准”行为？），并且没有更多的代码

从：

异步函数可以包含一个等待表达式，该表达式暂停异步函数的执行以等待传递的承诺的解析，然后恢复异步函数的执行并作为解析值进行计算

对于一些“幕后”的见解，您可能想看看由Babel之类的Transpiler生成的ES5代码（IIRC它使用生成器来处理这个问题）

如果这是一个错误，为什么处理程序没有为未捕获的异常调用它

如果未使用
reject
抛出或传递
error，则程序不知道
error
是错误

当承诺无法运行其代码时，如何忽略错误

无论是
解决
（而不是
拒绝
）还是
拒绝
，然后围绕
等待
做经典的尝试/捕捉。首先，你混合了两个实现相同目标的概念，即创造承诺。您正在混合
async/await
和
newpromise

这使得你实际上有两个连锁承诺

为什么程序在未调用reject（）时停止

因为您正在返回一个承诺，而承诺本身要求调用resolve或reject回调

如果这是一个错误，为什么处理程序没有为未捕获的异常调用它

没有实际的错误，唯一发生的事情是没有满足if子句

当承诺无法运行其代码时，如何忽略错误

再一次，承诺并没有失败运行它的代码，你没有理解这个概念

要使其更容易，请使用以下方法：

function CreateSession(){
   return new Promise((resolve, reject) => {
      if( <yourconditionhere> ){
         resolve(res);
      }else{
         reject(error);
      }
   });
}


CreateSession
.then((res) => {
   // code to execute in case of success (resolve)
   // receiving as argument the argument of the resolve call.
   AnotherCode();
})
.catch( error => {
   // code to execute in case of non-success (reject)
   // receiving as argument the argument of the reject call.
});

函数CreateSession（）{
返回新承诺（（解决、拒绝）=>{
如果（）{
决议（res）；
}否则{
拒绝（错误）；
}
});
}
创建会话
。然后（（res）=>{
//成功时要执行的代码（解析）
//接收解析调用的参数作为参数。
另一个代码（）；
})
.catch（错误=>{
//不成功时执行的代码（拒绝）
//接收拒绝调用的参数作为参数。
});

或

异步函数CreateSession（）{
let res=等待请求（选项、功能（错误、响应、正文）{
如果（）{
返回。。。；
}否则{
返回。。。；
}
}
返回res；
}
异步函数MyFunction（）
{
var sessionId=await CreateSession（）；
另一个代码（）；
}
首先，您混合了两个实现相同目标的概念，即创建承诺。您混合了
async/await
和
new Promise

这使得你实际上有两个连锁承诺

为什么程序在未调用reject（）时停止

因为您正在返回一个承诺，而承诺本身要求调用resolve或reject回调

如果这是一个错误，为什么处理程序没有为未捕获的异常调用它

没有实际的错误，唯一发生的事情是没有满足if子句

当承诺无法运行其代码时，如何忽略错误

再一次，承诺并没有失败运行它的代码，你没有理解这个概念

要使其更容易，请使用以下方法：

function CreateSession(){
   return new Promise((resolve, reject) => {
      if( <yourconditionhere> ){
         resolve(res);
      }else{
         reject(error);
      }
   });
}


CreateSession
.then((res) => {
   // code to execute in case of success (resolve)
   // receiving as argument the argument of the resolve call.
   AnotherCode();
})
.catch( error => {
   // code to execute in case of non-success (reject)
   // receiving as argument the argument of the reject call.
});

函数CreateSession（）{
返回新承诺（（解决、拒绝）=>{
如果（）{
决议（res）；
}否则{
拒绝（错误）；
}
});
}
创建会话
。然后（（res）=>{
//成功时要执行的代码（解析）