Que se passe-t-il lorsque la promesse est cédée en javascript?

Je n'ai pas trouvé la réponse complète …

Que se passe-t-il lorsque la promesse est cédée?

Une telle construction

var p = new Promise() p.resolve(value) function * (){ yield p } 

équivalent à

 function * (){ yield value } 

?

METTRE À JOUR

Comment mélanger différents styles de programmation asynchrone, par exemple pour un cadre comme koa?

Koa middlewares travaille avec des générateurs, mais il existe de nombreux bons paquets qui sont basés sur les promesses (suite à l'ex.)

Comme le dit Felix, une promesse n'est qu'une autre valeur à céder.

Cependant, il existe un style d'écriture de code asynchrone qui utilise des promesses cédées d'une manière particulière. Cela implique un code environnant qui invoque le générateur, puis attend la promesse cédée à résoudre, puis demande alors au générateur de la valeur suivante. Cela vous permet d'écrire vos programmes comme suit:

 function goGenerator *() { var userData = yield getUserData(); yield checkuserData(userData); } 

Là où getUserData et checkUserData une promesse. C'est un peu plus propre que d'avoir à écrire

 function goPromises() { return getUserData() . then(checkUserData); } 

Surtout s'il y a plus de promesses. Ce style basé sur le générateur se lit séquentiellement et rappelle une approche de la fonction asynchrone.

 async function goAsyncFunction() { var userData = await getUserData(); return await checkUserData(userData); } 

Mais les fonctions asynchrones ne sont pas encore largement prises en charge. L'approche basée sur le générateur est une alternative qui fonctionne avec ES6 pur.

Comme je l'ai mentionné, l'approche basée sur le générateur nécessite un code "entourant" qui sait ce qu'il faut faire avec les promesses cédées – ce qui, comme je l'ai dit, c'est d'attendre leur résolution avant d'appeler à nouveau le générateur. La mise en œuvre classique de cela est co vous pouvez Google. Ou vous pouvez écrire votre propre:

 function spawn(generator) { var iterator = generator(); return new Promise( resolve => function iterate(val) { var {value, done} = iterator.next(val); if (done) { resolve(val); } else { Promise.resolve(value).then(iterate); } }() ); } 

Maintenant, vous exécutez spawn(goGenerator) . spawn lui-même une promesse, afin que vous puissiez accrocher plus de choses: spawn(goGenerator) . then(doMoreStuff) spawn(goGenerator) . then(doMoreStuff) .

Il s'agit d'une implémentation très simple. co a beaucoup d'autres fonctionnalités – par exemple, vous pouvez yield une série de promesses, et cela les attendra pour que tous puissent résoudre, a la Promise.all .

Que se passe-t-il lorsque la promesse est cédée?

Rien de spécial. Une promesse n'est qu'un objet. Le générateur produira cette promesse et vous pourrez vous y abonner:

 var promise = generator().next().value; promise.then(...);