@Jordan Pertama sekali, seperti yang dinyatakan oleh pengulas, contoh pertama anda pasti akan menghasilkan hasil yang anda jangkakan apabila menggunakan perpustakaan yang malas:

promise1 rejected
promise2 rejected
promise3 rejected

Kedua, walaupun ia menghasilkan output yang anda cadangkan, ia tidak menjejaskan aliran pelaksanaan coretan kod kedua, yang agak berbeza dan lebih seperti:

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});

Dan, jika janji pertama ditolak, hanya keluaran:

promise1 rejected

Walau bagaimanapun (mencapai bahagian yang menyeronokkan) malah perpustakaan tertunda pasti kembali 3 x returned，大多数其他承诺库将返回 1 x returned， 2 x 已解决 (yang membawa kepada andaian bahawa anda mendapat keputusan ini dengan menggunakan beberapa perpustakaan Promise yang lain).

Juga mengelirukan, perpustakaan lain berkelakuan lebih betul. Biar saya jelaskan.

Dalam dunia segerak, rakan sejawat untuk "penolakan janji" ialah 抛出。因此从语义上讲，同步中的异步 deferred.reject(new Error()) 等于 throw new Error(). Dalam contoh anda, anda tidak membuang ralat dalam panggilan balik segerak, anda hanya mengembalikannya, jadi anda beralih kepada aliran kejayaan di mana ralat adalah nilai kejayaan. Untuk memastikan penolakan berjalan lebih jauh, anda perlu membuang semula ralat:

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

Sekarang persoalannya ialah, mengapa perpustakaan kelewatan menganggap ralat yang dikembalikan sebagai penolakan?

Sebabnya, penolakan dalam kerja tertangguh sedikit berbeza. Dalam lib tertunda, peraturannya ialah: Apabila kejadian ralat berlaku, janji ditolak , jadi walaupun anda melaksanakan panggilan balik deferred.resolve(new Error()) 它也会起作用如 deferred.reject(new Error()) ，如果你尝试执行 deferred.reject(notAnError) ，它会抛出一个异常，表示该 Promise 只能被拒绝有错误的实例。这清楚地表明了为什么从 then ralat yang dikembalikan menolak janji.

tunda, tetapi ia masih tidak sepadan dengan cara throw berfungsi dalam JavaScript, jadi tingkah laku ini dijadualkan berubah dalam keluaran v0.7 yang tertunda.

Ringkasan ringkas:

Untuk mengelakkan kekeliruan dan keputusan yang tidak dijangka, ikut sahaja peraturan amalan yang baik:

1. Sentiasa menolak janji dengan contoh yang salah (mengikut peraturan dunia segerak, di mana membuang nilai yang tidak salah dianggap amalan buruk).
2. Baling ralat melalui panggilan balik penyegerakan penolakan (memulangkan ralat tidak menjamin penolakan).

Patuhi perkara di atas dan anda akan mendapat keputusan yang konsisten dan dijangka dalam perpustakaan tertunda dan perpustakaan Promise popular yang lain.

Tidak. Perkara yang anda huraikan bukanlah rantaian, tetapi hanya menambahkan semua panggilan balik pada d1。然而，如果您想使用 then 链接某些内容，promise2 的结果取决于 promise1 的分辨率以及 promise1 的分辨率以及 然后panggilan balik yang mengendalikannya.

Dokumentasi menyatakan:

.then 方法通常根据 Promises 来看待/A 规范（或者更严格的Promsises/A+ ）。这意味着回调 shell 返回的 Promise 将被同化为 Promise2 的解析，如果没有成功/错误处理程序，相应的结果将直接传递给 Promise2 kod> - jadi anda boleh meninggalkan pengendali untuk menyebarkan ralat.

Walau bagaimanapun, jika ralat diuruskan, promise2 yang terhasil dianggap tetap dan akan dipenuhi dengan nilai tersebut. Jika anda tidak mahu perkara ini berlaku, anda mesti promise2 被视为已修复，并将用该值来实现。如果您不希望出现这种情况，则必须重新抛出melempar semula ralat sama seperti dalam klausa cuba-tangkap. Sebagai alternatif, anda boleh mengembalikan janji yang ditolak (tertunda) daripada pengendali. Tidak pasti apakah penolakan Dojo, tetapi:

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());

Dia sepatutnya tidak boleh. Tanpa pengendali ralat, dia hanya akan melihat mesej bahawa tiada widget yang tinggal ((dari John) daripada Ginger Walau bagaimanapun, jika Ginger menetapkan pengendali ralat untuk situasi ini, jika John atau peniaganya Tanpa widget biru yang tinggal, dia masih boleh menunaikan janjinya untuk memberikan Bob widget hijau dari kabinnya sendiri

Untuk menukar panggilan balik ralat kepada meta, kembalikan ralat daripada pengendali seperti berkata "Jika tiada widget yang tinggal, berikan sahaja komen kepadanya bahawa tiada widget yang tinggal - ini adalah sama dengan widget yang diperlukan baik".

...maksudnya ralat telah diuruskan di situ. Jika tidak, tinggalkan sahaja panggilan balik ralat. BTW, panggilan balik kejayaan anda tidak 返回 janji yang mereka buat, jadi ia kelihatan tidak berguna. Yang betul ialah:

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();
        });
    });
});

Atau, kerana anda tidak memerlukan penutupan untuk mengakses nilai hasil panggilan balik sebelumnya, malah:

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);