La construction d'une promesse de la chaîne de manière récursive en javascript - considérations relatives à la mémoire

une pile d'appel et une promesse de la chaîne d' - ie "profonde" et "large".

En fait, non. Il n'y a pas de promesse de la chaîne d'ici comme nous le savons de doSomeThingAsynchronous.then(doSomethingAsynchronous).then(doSomethingAsynchronous).… (qui est ce que Promise.each ou Promise.reduce pourrait le faire de façon séquentielle exécuter des gestionnaires s'il a été écrit de cette façon).

Ce que nous sommes confrontés ici est un résoudre chaîne¹ - ce qui se passe à la fin, quand le cas de base de la récurrence est rencontré, c'est quelque chose comme Promise.resolve(Promise.resolve(Promise.resolve(…))). Ce n'est "profond", pas "large", si vous voulez appeler ça comme ça.

Je m'attends à une mémoire de spike plus grand que l'autre l'exécution d'une récursivité ou la construction d'une promesse de la chaîne d'seule.

Pas un pic en fait. Vous auriez lentement, au fil du temps, de construire un ensemble de promesses qui sont résolus avec le plus profond, le tout représentant le même résultat. Lorsque, à la fin de votre tâche, la condition est remplie et l'intime promesse résolu avec une valeur réelle, toutes ces promesses doivent être résolus avec la même valeur. Que serait O(n) coût pour la marche jusqu'à la résolution de la chaîne (si mis en œuvre naïvement, ce pourrait même être fait de manière récursive et de provoquer un débordement de pile). Après cela, toutes les promesses, sauf pour les rup peuvent devenir des ordures.

En revanche, une promesse de la chaîne qui est construit par quelque chose comme

[…].reduce(function(prev, val) {
    //successive execution of fn for all vals in array
    return prev.then(() => fn(val));
}, Promise.resolve())

montrent un pic, l'allocation de n promesse objets en même temps, et puis, lentement, les résoudre un par un, les ordures, collecte de la précédente, jusqu'à ce que seulement réglées à la fin de la promesse est vivant.

memory
  ^     resolve      promise "then"    (tail)
  |      chain          chain         recursion
  |        /|           |\
  |       / |           | \
  |      /  |           |  \
  |  ___/   |___     ___|   \___     ___________
  |
  +----------------------------------------------> time

Est-ce donc?

Pas nécessairement. Comme dit ci-dessus, toutes les promesses que la plupart sont en fin de compte réglé avec la même valeur², de sorte que tous nous avons besoin est de stocker de l'infiniment grand et l'infiniment petit de la promesse à la fois. Tous les intermédiaires de promesses peuvent devenir des ordures collectées dès que possible, et nous voulons exécuter cette récursivité dans la constante de l'espace et du temps.

En fait, cette récursive de construire est totalement nécessaire pour boucles asynchrones avec un état dynamique (pas de nombre fixe d'étapes), vous ne pouvez pas vraiment l'éviter. En Haskell, où il est utilisé tout le temps pour le IO monade, une optimisation pour il est mis en place seulement en raison de ce cas. Il est très similaire à queue appelons récursivité, qui est habituellement éliminés par les compilateurs.

Quelqu'un a examiné les problèmes de mémoire de la construction d'une chaîne de cette façon?

Oui. C'était discuté lors de promesses/aplus par exemple, mais sans résultat encore.

Beaucoup de promesse de bibliothèques à prendre en charge l'itération des aides pour éviter le pic de la promesse then les chaînes, comme le Bluebird est each et map méthodes.

Ma propre promesse de la bibliothèque^3,4 ne disposent d'résoudre les chaînes sans introduire de la mémoire ou de l'exécution de frais généraux. Lorsqu'une promesse adopte un autre (même s'il est toujours en attente), ils deviennent indiscernables, les intermédiaires et les promesses ne sont plus référencés.

La mémoire de consommation diffèrent entre les promesses libs?

Oui. Bien que ce cas peut être optimisé, il est rarement. Plus précisément, l'ES6 spec ne nécessitent Promet d'inspecter la valeur à chaque resolve appel, de sorte que l'effondrement de la chaîne n'est pas possible. Les promesses de la chaîne, peut même être résolu avec des valeurs différentes (par la construction d'un exemple d'objet d'abus de getters, pas dans la vraie vie). La question a été soulevée sur esdiscuss mais reste en suspens.

Donc, si vous utilisez une fuite de la mise en œuvre, mais il faut asynchrone récursivité, alors il vaut mieux revenir à des rappels et l'utilisation de la différés antipattern à se propager le plus profond promesse résultat à un résultat unique promesse.

<sub>[1]: pas de terminologie officielle

[2]: eh bien, ils sont résolus les uns avec les autres. Mais nous voulez à régler avec la même valeur, nous attendre qui

[3]: sans-papiers, aire de jeux, passe aplus. Lire le code à vos risques et périls: https://github.com/bergus/F-Promise

[4]: également mis en œuvre pour la Croyance en ce pull request</sub>

OriginalL'auteur Bergi

Je vient de sortir un hack qui peut aider à résoudre le problème: ne pas faire de la récursivité dans la dernière then, plutôt, de le faire dans la dernière catch, depuis catch est hors de la volonté de la chaîne. À l'aide de votre exemple, il serait comme ceci:

function foo() {
    function doo() {
        //always return a promise
        if (/* more to do */) {
            return doSomethingAsync().then(function(){
                        throw "next";
                    }).catch(function(err) {
                        if (err == "next") doo();
                    })
        } else {
            return Promise.resolve();
        }
    }
    return doo(); //returns a promise
}

OriginalL'auteur dotslashlu

Cette promesse modèle va générer une chaîne récurrente. Ainsi, chaque résoudre() permet de créer un nouveau cadre de pile (avec ses propres données), en utilisant la mémoire. Cela signifie qu'un grand nombre de enchaînés fonctions à l'aide de cette promesse modèle peut produire des erreurs de dépassement de pile.

Pour illustrer cela, je vais utiliser un petit promesse bibliothèque appelée Séquence, que j'ai écrit. Il s'appuie sur la récursivité pour parvenir à l'exécution séquentielle pour les chaînes de fonctions:

var funcA = function() { 
setTimeout(function() {console.log("funcA")}, 2000);
};
var funcB = function() { 
setTimeout(function() {console.log("funcB")}, 1000);
};
sequence().chain(funcA).chain(funcB).execute();

Séquence fonctionne très bien pour les petites/moyennes chaînes, dans la gamme de 0-500 fonctions. Cependant, à environ 600 chaînes de Séquence commence degradating et générant souvent des erreurs de dépassement de pile.

La ligne de fond est: actuellement, la récursivité à base de promesse bibliothèques sont plus adaptés pour les petites/moyennes fonction de chaînes, même de réduire la base de la promesse implémentations sont ok pour tous les cas, y compris les grandes chaînes.

Bien sûr, cela ne signifie pas que la récursivité à base de promesses sont mauvais. Nous avons juste besoin de les utiliser avec leurs limites dans l'esprit. Aussi, il est rare que vous aurez besoin de chaîne que de nombreux appels (>=500) par l'intermédiaire de promesses. En général, je me retrouve à l'utiliser pour async configurations qui utilisent fortement ajax. Mais même si les cas les plus complexes, je n'ai pas vu une situation avec plus de 15 chaînes.

Sur une note de côté...

Ces statistiques ont été récupérées à partir de tests réalisés avec un autre de mes bibliothèques - provisnr - qui capte le nombre d'appels de fonction à l'intérieur d'un intervalle donné de temps.

OriginalL'auteur neatsu