@Jordan Tout d'abord, comme l'ont souligné les commentateurs, votre premier exemple produira certainement les résultats que vous attendez lorsque vous utilisez une bibliothèque paresseuse :

promise1 rejected promise2 rejected promise3 rejected

Deuxièmement, même s'il produit le résultat que vous suggérez, cela n'affecte pas le flux d'exécution du deuxième extrait de code, qui est un peu différent et ressemble plus à :

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

Et, si la première promesse est rejetée, seul résultat :

promise1 rejected

Cependant (passons à la partie amusante) même la bibliothèque différée revient définitivement3 x returned，大多数其他承诺库将返回1 x returned， 2 x 已解决(ce qui laisse supposer que vous obtenez ces résultats en utilisant une autre bibliothèque Promise).

Également déroutant, d'autres bibliothèques se comportent plus correctement. Laisse-moi expliquer.

Dans le monde synchrone, la contrepartie du « rejet de promesse » est抛出。因此从语义上讲，同步中的异步deferred.reject(new Error())等于throw new Error(). Dans votre exemple, vous ne lancez pas d'erreurs dans le rappel synchrone, vous les renvoyez simplement, vous passez donc au flux de réussite où les erreurs sont les valeurs de réussite. Pour vous assurer que le rejet va plus loin, vous devez renvoyer l'erreur :

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

Maintenant, la question est : pourquoi la bibliothèque de retard traite-t-elle l'erreur renvoyée comme un rejet ?

La raison est que le rejet en cas de retard de travail est un peu différent. Dans la bibliothèque différée, la règle est la suivante :Lorsqu'une instance d'erreur se produit, la promesse est rejetée, donc même si vous exécutez le rappeldeferred.resolve(new Error())它也会起作用如 deferred.reject(new Error()) ，如果你尝试执行 deferred.reject(notAnError) ，它会抛出一个异常，表示该 Promise 只能被拒绝有错误的实例。这清楚地表明了为什么从then, l'erreur renvoyée rejette la promesse.

Il existe un raisonnement valable derrière la logique

defer, mais elle ne correspond toujours pas à la façon dontthrowfonctionne en JavaScript, ce comportement devrait donc changer dans la version retardée v0.7.

Court résumé :

Pour éviter toute confusion et résultats inattendus, suivez simplement les règles de bonne pratique :

1. Rejetez toujours les promesses avec des instances erronées (en suivant les règles du monde synchrone, où lancer des valeurs non erronées est considéré comme une mauvaise pratique).
2. Lancezune erreur via le rappel de synchronisationrejection (le renvoi d'une erreur ne garantit pas le rejet).

Adhérez à ce qui précède et vous obtiendrez des résultats cohérents et attendus dans les bibliothèques différées et d'autres bibliothèques Promise populaires.

Non. Ce que vous décrivez n'est pas une chaîne, mais simplement l'ajout de tous les rappels aud1。然而，如果您想使用then链接某些内容，promise2的结果取决于promise1的分辨率以及promise1的分辨率以及 然后rappel qui le gère.

La documentation indique :

.then方法通常根据Promises 来看待/A 规范（或者更严格的Promsises/A+）。这意味着回调 shell 返回的 Promise 将被同化为 Promise2 的解析，如果没有成功/错误处理程序，相应的结果将直接传递给 Promise2 code> - vous pouvez donc simplementomettre le gestionnairepour propager l'erreur.

Cependant, si l'erreur estgérée, lapromise2résultante est considérée comme corrigée et sera remplie avec cette valeur. Si vous ne voulez pas que cela se produise, vous devezpromise2被视为已修复，并将用该值来实现。如果您不希望出现这种情况，则必须重新抛出re-lancer l'erreurcomme dans une clause try-catch. Alternativement, vous pouvez renvoyer une promesse rejetée (en attente) du gestionnaire. Je ne sais pas quel est le rejet du Dojo, mais :

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

Il ne devrait pas pouvoir le faire. Sans gestionnaire d'erreurs, il ne percevrait que le message indiquant qu'il n'y a plus de widgets ((de John) de Ginger. Cependant, si Ginger définit un gestionnaire d'erreurs pour cette situation, si John ou son revendeur n'a plus de widgets bleus, elle). peut encore tenir sa promesse d'offrir à Bob un widget vert depuis sa propre cabane

.

Pour convertir le rappel d'erreur en méta, renvoyez l'erreur du gestionnaire comme en disant "S'il ne reste aucun widget, donnez-lui simplement un commentaire indiquant qu'il ne reste aucun widget - c'est la même chose que le bon widget requis".

...ce qui signifie que l'erreur a été traitée ici. Si ce n'est pas le cas, omettez simplement le rappel d'erreur. BTW, vos rappels de réussite ne tiennent pas la promesse qu'ils créent, ils semblent donc inutiles. La bonne est :返回

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

Ou, puisque vous n'avez pas besoin de fermeture pour accéder à la valeur du résultat du rappel précédent, même :

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