对我来说，这个结果是没有意义的，通过附加到这个承诺链，每个then都暗示了它将依赖于d1的成功解析和一个结果被传递到链中的意图
不，您所描述的不是一个链，而只是将所有回调附加到d1。然而，如果您想用then链接某个东西，promise2的结果取决于promise1 * 的分辨率以及then回调如何处理它 *。
文件指出：
返回回调结果的新承诺。
.then方法通常被看作是Promises/A specification（或者更严格的Promsises/A+ one）。这意味着回调shell返回的承诺将被同化为promise2的解决方案，如果没有成功/错误处理程序，则相应的结果将直接传递到promise2-因此您可以简单地省略处理程序以传播错误。
然而，如果错误是 handled，则结果promise2被视为已修复，并将使用该值来实现。如果不希望这样，则必须re-throw错误，就像try-catch子句中一样。或者，可以从处理程序返回（to-be-）rejected promise。不确定Dojo的拒绝方式是什么，但是：

var d1 = d();

var promise1 = d1.promise.then(
    function(wins) { console.log('promise1 resolved'); return wins;},
    function(err) { console.log('promise1 rejected'); throw err;});
var promise2 = promise1.then(
    function(wins) { console.log('promise2 resolved'); return wins;},
    function(err) { console.log('promise2 rejected'); throw err;});
var promise3 = promise2.then(
    function(wins) { console.log('promise3 resolved'); return wins;},
    function(err) { console.log('promise3 rejected'); throw err;});
d1.reject(new Error());

鲍勃怎么能从金吉尔那里得到一个蓝色的小部件，而她自己却没有呢？
他应该不能。如果没有错误处理程序，他只会收到消息（（（来自分发者）来自约翰）来自金吉尔），没有剩余的小部件。然而，如果金吉尔为这种情况设置了错误处理程序，如果约翰或他的分发者没有剩余的蓝色小部件，她仍然可以履行承诺，从自己的小屋给予鲍勃一个绿色的小部件。
为了将错误回调转换为metapher，来自处理程序的return err就像是说“如果没有剩下的小部件，就给予他一个提示，没有剩下的小部件--这和想要的小部件一样好”。
在数据库情况下，如果db.query失败，它将调用第一个函数的err函数，然后
...这意味着错误在那里处理。如果你不这样做，就省略错误回调函数。顺便说一句，你的成功回调函数并没有实现它们所创造的承诺，所以它们看起来是相当无用的。正确的做法是：

var promise = db.query({parent_id: value});
promise.then(function(query_result) {
    var first_value = {
        parent_id: query_result[0].parent_id
    }
    var promise = db.put(first_value);
    return promise.then(function(first_value_result) {
        var second_value = {
            reference_to_first_value_id: first_value_result.id
        }
        var promise = db.put(second_value);
        return promise.then(function(second_value_result) {
            return values_successfully_entered();
        });
    });
});

或者，因为您不需要闭包来访问之前回调的结果值，甚至：

db.query({parent_id: value}).then(function(query_result) {
    return db.put({
        parent_id: query_result[0].parent_id
    });
}).then(function(first_value_result) {
    return db.put({
        reference_to_first_value_id: first_value_result.id
    });
}.then(values_successfully_entered);

@Jordan首先，正如评论者所指出的，当使用deferred lib时，你的第一个例子肯定会产生你所期望的结果：

promise1 rejected
promise2 rejected
promise3 rejected

其次，即使它会产生您建议的输出，也不会影响第二个代码段的执行流，这有点不同，更像是：

promise.then(function(first_value) {
    console.log('promise1 resolved');
    var promise = db.put(first_value);
    promise.then(function (second_value) {
         console.log('promise2 resolved');
         var promise = db.put(second_value);
         promise.then(
             function (wins) { console.log('promise3 resolved'); },
             function (err) { console.log('promise3 rejected'); return err; });
    }, function (err) { console.log('promise2 rejected'); return err;});
}, function (err) { console.log('promise1 rejected'); return err});

并且在第一承诺被拒绝的情况下将仅仅输出：

promise1 rejected

然而（进入最有趣的部分）即使延迟库肯定返回3 x rejected，大多数其他promise库也会返回1 x rejected, 2 x resolved（这导致假设您通过使用其他promise库来获得这些结果）。
更令人困惑的是，其他库的行为更正确，让我来解释一下。
在同步世界中，“promise rejection”的对应值是throw。因此，从语义上讲，async deferred.reject(new Error()) in sync等于throw new Error()。在您的示例中，您没有在同步回调中抛出错误，您只是返回它们，因此您切换到成功流，错误值为成功值。为了确保拒绝被进一步传递，您需要重新抛出错误：

function (err) { console.log('promise1 rejected'); throw err; });

所以现在的问题是，为什么延迟库把返回的错误当作拒绝？
原因是deferred中的reject的工作方式有点不同，deferred lib中的规则是：promise在使用error示例解析时被拒绝，因此即使您执行deferred.resolve(new Error())，它也将充当deferred.reject(new Error())，如果您尝试执行deferred.reject(notAnError)，它将抛出一个异常，说明该promise只能在使用error示例时被拒绝。这就清楚了为什么从then回调返回的error会拒绝该promise。
延迟逻辑背后有一些合理的推理，但它仍然不能与throw在JavaScript中的工作方式相提并论，因此，延迟逻辑的v0.7版本计划更改此行为。
简短总结：
为避免混淆和意外结果，请遵循良好实践规则：
1.总是用一个错误示例来拒绝你的承诺（遵循同步世界的规则，抛出不是错误的值被认为是一个坏习惯）。
1.通过抛出错误来拒绝同步回调（返回错误并不保证会被拒绝）。
遵循上述原则，您将在延迟和其他流行的promise库中获得一致和预期的结果。

用户可以在承诺的每一层 Package 错误。我将错误链接在TraceError中：

class TraceError extends Error {
  constructor(message, ...causes) {
    super(message);

    const stack = Object.getOwnPropertyDescriptor(this, 'stack');

    Object.defineProperty(this, 'stack', {
      get: () => {
        const stacktrace = stack.get.call(this);
        let causeStacktrace = '';

        for (const cause of causes) {
          if (cause.sourceStack) { // trigger lookup
            causeStacktrace += `\n${cause.sourceStack}`;
          } else if (cause instanceof Error) {
            causeStacktrace += `\n${cause.stack}`;
          } else {
            try {
              const json = JSON.stringify(cause, null, 2);
              causeStacktrace += `\n${json.split('\n').join('\n    ')}`;
            } catch (e) {
              causeStacktrace += `\n${cause}`;
              // ignore
            }
          }
        }

        causeStacktrace = causeStacktrace.split('\n').join('\n    ');

        return stacktrace + causeStacktrace;
      }
    });

    // access first error
    Object.defineProperty(this, 'cause', {value: () => causes[0], enumerable: false, writable: false});

    // untested; access cause stack with error.causes()
    Object.defineProperty(this, 'causes', {value: () => causes, enumerable: false, writable: false});
  }
}

用法

throw new TraceError('Could not set status', srcError, ...otherErrors);

产出

职能

TraceError#cause - first error
TraceError#causes - list of chained errors

here的简单解释：
在一个常规的try..catch中，我们可以分析错误，如果它不能被处理，我们可以重新抛出它。
如果我们在.catch内抛出，则控件转到下一个最近的错误处理程序。但是如果我们处理错误并正常完成，则控件继续转到下一个最近的成功的.then处理程序。
在下面的示例中，.catch成功处理了错误：

new Promise((resolve, reject) => {

  throw new Error("Whoops!");

}).catch(function(error) {

  alert("The error is handled, continue normally");

}).then(() => alert("Next successful handler runs"));

这里catch块正常完成，所以调用下一个成功的then处理程序。
注意，我们可以拥有任意多的.then处理程序，然后在末尾使用一个.catch来处理所有这些处理程序中的错误。
如果你有中间的catch块，并且你想中断下一个链函数的错误，你应该重新抛出catch块内的错误，以表明这个错误没有被完全处理。

new Promise((resolve, reject) => {

  throw new Error("Whoops!");

}).catch(function(error) { // (*) first catch

  if (error instanceof URIError) { //just as example
    // handle it...
  } else {
    alert("Can't handle such error");
    throw error; // throwing this jumps to the next catch
  }

}).then(function() {

  // our error is other than URIError, so: 
  // the code doesn't reach here (jump to next catch)

}).catch(error => { // (**) second catch

  alert(`The unknown error has occurred: ${error}`);
  // don't return anything => execution goes the normal way

});

在上面的例子中，我们看到第一个catch（）将捕获错误，但不能处理它（例如，它只知道如何处理URIError），所以它再次抛出它。执行从第一个catch（）跳到链中的下一个catch（**）。