Javascript 是什么决定了node.js（控制台/脚本）中未处理承诺拒绝？

根据我的理解，如果我不得不过于简化，Javascript承诺是一种“通过

.then（）

方法安排的稍后处理内容的方法”

在我的终端中执行以下操作后：

BASE$> node
> var promise = Promise.reject("reason 42");

因此，我很高兴看到这个结果：

> (node:8783) UnhandledPromiseRejectionWarning: reason 42
(node:8783) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 1)
(node:8783) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

因为我正要写

> promise.catch(console.log);

激发这个问题的因素是：
我是否可以合理地确定

node.js

只会触发此警告（以及威胁“将来我将完全退出”，因为代码是在node.js控制台中逐步运行的/

node.js

是如何得出拒绝承诺的结论的

因此，我已经测试了以下不同的工作方式

在一次REPL迭代中组合的“相同代码”的评估：

var promise=promise.reject（“原因42”）；promise.catch（console.log）；

从包含内容的文件（例如

tmp.js

）中评估“相同代码” var promise = Promise.reject("reason 42") promise.catch(console.log);`) 风险值承诺=承诺。拒绝（“理由42”） promise.catch（console.log）；`） 通过

节点tmp.js

两者都会产生预期的输出“

原因42

”，不会显示任何警告，如上文所示

---

因此，这是如何实现的？我的假设是否可以确认，在节点控制台

REPL

中确定未处理的承诺是每个

REPL

循环迭代中的到达端？

以便将承诺拒绝视为已处理，它应该用

catch

或

链接，然后在同一刻度上用两个参数链接

这将导致
未处理的PromisejectionWarning
：

var promise = Promise.reject("reason 42");

setTimeout(() => {
  promise.catch(console.error);
});

var promise = Promise.reject("reason 42");
promise.catch(console.error);

这不会导致
未处理的PromisejectionWarning
：

var promise = Promise.reject("reason 42");

setTimeout(() => {
  promise.catch(console.error);
});

var promise = Promise.reject("reason 42");
promise.catch(console.error);

Node.js REPL中异步计算的行会导致它们之间的延迟。为了按照行的写入顺序同步计算行，可以使用。或者，可以将代码编写为明确地作为块进行计算：

;{
var promise = Promise.reject("reason 42");
promise.catch(console.error);
}

或生命：

(() => {
var promise = Promise.reject("reason 42");
promise.catch(console.error);
})()

为了将拒绝承诺视为已处理，应使用
catch
或
链接，然后在同一刻度上使用两个参数

这将导致
未处理的PromisejectionWarning
：

var promise = Promise.reject("reason 42");

setTimeout(() => {
  promise.catch(console.error);
});

var promise = Promise.reject("reason 42");
promise.catch(console.error);

这不会导致
未处理的PromisejectionWarning
：

var promise = Promise.reject("reason 42");

setTimeout(() => {
  promise.catch(console.error);
});

var promise = Promise.reject("reason 42");
promise.catch(console.error);

Node.js REPL中异步计算的行会导致它们之间的延迟。为了按照行的写入顺序同步计算行，可以使用。或者，可以将代码编写为明确地作为块进行计算：

;{
var promise = Promise.reject("reason 42");
promise.catch(console.error);
}

或生命：

(() => {
var promise = Promise.reject("reason 42");
promise.catch(console.error);
})()

我想扩展一下@estus的答案，特别是第一句话：

为了使承诺拒绝被认为是已处理的，它应该与catch链接，或者在同一勾号上与两个参数链接

我不完全同意这一点。我认为，调用
然后
或
捕获
的每个承诺都是好的，但是在调用这些方法时，您创建了新的承诺，而它们只是继承了问题

我们经常谈论承诺链，但实际上它是一棵树，因为您可以从同一个“父”分支多个“子承诺”，错误会影响所有承诺

const root = Promise.reject("reason 42");

const a = root.then(value => value*2)
              .then(...);

const b = root.then(value => value*3)
              .then(...);

因此，你建立了一个承诺链/承诺树；出现错误。错误将传播到该树中的子承诺。。。如果该（或任何其他）错误达到任何leaf promise（未被捕获），您将收到
未经处理的PromisejectionWarning

通过承诺，你可以做很多事情，你如何链接/分支承诺，如何/在哪里发现错误。。。所以我能给你的最好的总结是：

因为
承诺
都是关于时间的，所以您有时间直到错误到达链的末端，才能
捕获它

我是否可以合理地确定node.js只会收到这些警告（以及“将来我会完全退出”的威胁），因为代码是在node.js控制台中逐步运行的

是的
我想扩展一下@estus的答案，特别是第一句话：

为了使承诺拒绝被认为是已处理的，它应该与catch链接，或者在同一勾号上与两个参数链接

我不完全同意这一点。我认为，调用
然后
或
捕获
的每个承诺都是好的，但是在调用这些方法时，你创建了新的承诺，而它们只是继承了问题

我们经常谈论承诺链，但实际上它是一棵树，因为您可以从同一个“父”分支多个“子承诺”，错误会影响所有承诺

const root = Promise.reject("reason 42");

const a = root.then(value => value*2)
              .then(...);

const b = root.then(value => value*3)
              .then(...);

因此，您构建了一个承诺链/树；出现了一个错误。该错误会传播到该树中的子承诺，…如果该（或任何其他）错误到达anyleaf promise（没有被捕捉到），您将得到
unhandledPromisejectionWarning

关于承诺，你可以做很多事情，你如何链接/分支承诺，如何/在哪里发现错误，……因此，我可以给你最好的总结：

因为
承诺
都是关于时间的，所以您有时间直到错误到达链的末端，才能
捕获它

我是否可以合理地确定node.js只会收到这些警告（以及“将来我会完全退出”的威胁），因为代码是在node.js控制台中逐步运行的

是的
因此，我很高兴看到这个结果，因为我正要写
它无法读懂你的心思-在那一点上，它不知道它会被处理。因此，与其等待一段不确定的时间，然后检查拒绝是否仍然未处理，它将立即抛出。
因此，我支持我很高兴看到这个结果，因为我正要写
，它无法读懂你的心思——在那一点上，