Javascript 链是否可以在不向控制台发送错误消息的情况下停止？

在下面的代码中，当我拒绝承诺时，我会看到第一个console.log，但也会看到第二个console.log。这是预期的，因为拒绝只影响下一个“then（）”

问题是，有没有一个操作符相当于循环中的“断开”，这样你就可以从链上跳下来？快速的答案是肯定的，带有非捕获的reject（）或throw（），但这两种方法都会向控制台发送错误消息（它们会停止整个代码执行吗？）

所以问题是，它能“干净地”完成吗？

*我的第一个假设是，通过捕获拒绝/错误，这将达到目的，但事实并非如此

Promise.resolve()
.then(function(){
  do stuff
  return Promise.resolve();
})
.then(function(){
  if (a === 'this')
    return Promise.resolve();
  else
    // is there any "break" equivalent here?
    return Promise.reject();
})
.then(function(){
  console.log('seen if not rejected');
},function(){
  console.log('seen if rejected');
})
.then(function(){
  console.log('seen all the time');
});

---

当您将第二个参数（

onRejected

函数）传递给

然后传递给

方法时，拒绝实际上被捕获。它也会返回一个承诺，所以你可以继续链接

如果在第三个

中删除
onRejected
函数，则

，您将在控制台中看到未捕获的异常，例如：

Promise.reject()
  .then(function(){
    console.log('resolved');
  })
  .then(function(){
    console.log('you cannot see me');
  })

// Uncaught (in promise)

是的，如果

onRejected

未捕获异常，您可以

捕获该异常：

Promise.reject()
  .then(function(){
    console.log('resolved');
  })
  .catch(function(){
    console.log('you can see me');
  })

// you can see me


Promise.reject()
  .then(function(){
    console.log('resolved');
  }, function(){
    console.log('rejected');
  })
  .catch(function(){
    console.log('you cannot see me');
  })

// rejected

根据我的经验，在实际业务场景中，我们通常希望分离不相关的逻辑。因此，我们将在
onRejected
中捕获拒绝，做一些事情，然后将异常抛出到
catch
方法中（无论是在自身还是在链接
then
）：

因为你被拒绝了。下面的两个块是等效的：

示例1

var stuff = function () {

};
var doStuff = function () {

};
var a = 'notThis';

Promise.resolve()
    .then(function () {
        doStuff();
        return Promise.resolve();
    })
    .then(function () {
        if (a === 'this')
            return Promise.resolve();
        else
            return Promise.reject();
    })
    .then(function () {
        stuff();
    }, function () {
        console.log('rejected, end of chain');
    })
    .then(function () {
        console.log('only executed if not rejected');
    });

示例2

var stuff = function () {

};
var doStuff = function () {

};
var a = 'notThis';

Promise.resolve()
    .then(function () {
        doStuff();
        return Promise.resolve();
    })
    .then(function () {
        if (a === 'this')
            return Promise.resolve();
        else
            return Promise.reject();
    })
    .then(function () {
        stuff();
    })
    .catch(function () {
        console.log('rejected, end of chain');
    })
    .then(function () {
        console.log('only executed if not rejected');
    });

然后（成功，错误）

回调返回承诺

即:

Promise.reject（）
.然后（函数（）{
//不会被要求，因为上述承诺被拒绝
}，函数（）{
//将被调用，并在默认情况下返回已解决的承诺；
//如果希望调用下一个错误回调，
//您需要返回被拒绝的承诺或抛出错误
})
.然后（函数（）{
//1:如果上面有，则调用。然后返回已解决的承诺
}，函数（）{
//2：如果在上面，则调用。然后返回被拒绝的承诺或抛出错误
})

引用错误：未定义（…）

@CoryDanielson这不是问题所在。他们会问，为什么返回被拒绝的承诺不会结束这一链条。因为您继续调用

。then（）

。then（）方法返回一个承诺。它有两个参数：成功的回调函数和承诺的失败案例。你的最后一个

.then（）

应该与

内容一起进入，而不是再次链接。这是因为你
在你记录
console.log（'rejected，end of chain'）的函数中捕捉到了拒绝
@MikeMcCaughan真的吗？这篇文章是针对AngularJS的，这可能会让没有棱角的人（甚至像我这样的初学者）感到困惑。也许我错了，但你能解释一下为什么不行吗？链接的答案已经解释了。如果你不明白什么，请问一下。
var stuff = function () {

};
var doStuff = function () {

};
var a = 'notThis';

Promise.resolve()
    .then(function () {
        doStuff();
        return Promise.resolve();
    })
    .then(function () {
        if (a === 'this')
            return Promise.resolve();
        else
            return Promise.reject();
    })
    .then(function () {
        stuff();
    })
    .catch(function () {
        console.log('rejected, end of chain');
    })
    .then(function () {
        console.log('only executed if not rejected');
    });