Quand les gestionnaires JavaScript Promise .then() s'exécutent-ils les uns par rapport aux autres ?

Comprendre l'ordre d'exécution dans les promesses JavaScript

Les promesses en JavaScript offrent un modèle de programmation asynchrone dans lequel le code est exécuté une fois un événement spécifique ou une promesse , est accompli. Cependant, lorsqu'il s'agit de plusieurs promesses, il est essentiel de comprendre l'ordre d'exécution pour éviter un comportement imprévisible.

Considérez l'extrait de code suivant :

Promise.resolve('A')
  .then(function(a){console.log(2, a); return 'B';})
  .then(function(a){
     Promise.resolve('C')
       .then(function(a){console.log(7, a);})
       .then(function(a){console.log(8, a);});
     console.log(3, a);
     return a;})
  .then(function(a){
     Promise.resolve('D')
       .then(function(a){console.log(9, a);})
       .then(function(a){console.log(10, a);});
     console.log(4, a);})
  .then(function(a){
     console.log(5, a);});
console.log(1);
setTimeout(function(){console.log(6)},0);

Lors de l'exécution, vous pouvez observer ce qui suit : ordre de sortie :

1
2 "A"
3 "B"
7 "C"
4 "B"
8 undefined
9 "D"
5 undefined
10 undefined
6

Comprendre l'ordre d'exécution

1. Les promesses sont résolues de manière asynchrone :
   Les promesses sont résolues indépendamment de le fil d'exécution actuel. Cela signifie que les gestionnaires .then() sont appelés de manière asynchrone une fois le thread en cours terminé.
2. Les promesses sont exécutées dans une file d'attente :
   .les gestionnaires then() sont programmés pour s'exécuter après le précédent. le gestionnaire se termine. Ils sont essentiellement mis en file d'attente, c'est pourquoi vous voyez 1, 2 "A" et 3 "B" imprimés dans cet ordre.
3. Les promesses intérieures créent des chaînes indépendantes :
   Promesses créées dans les gestionnaires .then() imbriqués, comme Promise.resolve('C') et Promise.resolve('D'), créez de nouvelles chaînes de promesses indépendantes. Ces chaînes internes ne se synchronisent pas intrinsèquement avec la chaîne externe.
4. L'ordre d'exécution n'est pas déterministe :
   L'ordre d'exécution de ces chaînes indépendantes n'est pas garanti. Dans ce cas, le moteur de promesse choisit d'exécuter les gestionnaires .then() des lignes 5 et 12 avant ceux des lignes 6 et 7.

Recommandations

Pour garantir un ordre d'exécution spécifique, évitez de créer des chaînes de promesses non synchronisées et comptez plutôt sur des promesses liées de manière séquentielle. Renvoie les promesses des gestionnaires internes .then() pour les enchaîner avec la promesse parent, comme indiqué ci-dessous :

Promise.resolve('A').then(function (a) {
    console.log(2, a);
    return 'B';
}).then(function (a) {
    var p = Promise.resolve('C').then(function (a) {
        console.log(7, a);
    }).then(function (a) {
        console.log(8, a);
    });
    console.log(3, a);
    return p; // Link the inner promise to the parent chain
}).then(function (a) {
    var p = Promise.resolve('D').then(function (a) {
        console.log(9, a);
    }).then(function (a) {
        console.log(10, a);
    });
    console.log(4, a);
    return p; // Link the inner promise to the parent chain
}).then(function (a) {
    console.log(5, a);
});

console.log(1);

setTimeout(function () {
    console.log(6)
}, 0);

Avec cette approche, l'ordre d'exécution devient entièrement déterministe : 1, 2 "A", 3 " B", 7 "C", 8 indéfini, 4 indéfini, 9 "D", 10 indéfini, 5 indéfini et 6.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!