La création d'un (ES6) promesse sans commencer à le résoudre

À l'aide de ES6 promesses, comment puis-je créer une promesse sans la définition de la logique pour le résoudre? Voici un exemple de base (certains caractères d'imprimerie):

var promises = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return promises[key];
  }
  var promise = new Promise(resolve => {
    //But I don't want to try resolving anything here :(
  });

  promises[key] = promise;
  return promise;
}

function resolveWith(key: string, value: any): void {
  promises[key].resolve(value); //Not valid :(
}

C'est facile à faire avec les autres promesse de bibliothèques. JQuery par exemple:

var deferreds = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return deferreds[key].promise();
  }
  var def = $.Deferred();    
  deferreds[key] = def;
  return def.promise();
}

function resolveWith(key: string, value: any): void {
  deferreds[key].resolve(value);
}

Le seul moyen que je vois pour ce faire serait de stocker les résoudre fonction quelque part dans la promesse de l'exécuteur testamentaire, mais qui semble sale, et je ne suis pas sûr qu'il est défini exactement quand cette fonction est exécutée - est-il toujours exécuter immédiatement sur l'industrie de la construction?

Grâce.

InformationsquelleAutor Barguast | 2015-06-26
  1. 58

    Bonne question!

    La résolution adoptée à la promesse du constructeur intentionnellement fonctionne synchrone afin de soutenir ce cas d'utilisation:

    var deferreds = [];
var p = new Promise(function(resolve, reject){
    deferreds.push({resolve: resolve, reject: reject});
});

    Puis, à un moment plus tard dans le temps:

     deferreds[0].resolve("Hello"); //resolve the promise with "Hello"

    La raison de la promesse constructeur, c'est que:

    • Généralement (mais pas toujours) la résolution logique est lié à la création.
    • La promesse du constructeur est de jeter un coffre-fort et convertit les exceptions à ces rejets.

    Parfois, il ne rentre pas et pour qu'il le solveur fonctionne de manière synchrone. Voici liées à la lecture sur le sujet.

    • Je pensais le long des lignes de Promise.resolve et le stockage lié à then. Mais, cela a l'air propre et je ne suis même pas sûr si la limite then fonctionne.
    • Wow. Merci pour l'incroyablement rapide et approfondie de la réponse! Auriez-vous une source indiquant que l'exécuteur testamentaire (la fonction avec le résoudre et de rejeter les arguments) fonctionne toujours de manière synchrone au moment de la construction?
    • lié thens ne fonctionnerait pas si vous n'avez pas à appliquer votre propre then fonction.
    • bien sûr, pour ES6 en particulier - ecma-international.org/ecma-262/6.0/... c'est la façon dont les promesses sont construits, qui appelle ecma-international.org/ecma-262/6.0/index.html#sec-construct est appelée de manière synchrone. Il est appelé à son tour de façon synchrone à partir de ecma-international.org/ecma-262/6.0/... - je pense que l'ancien github.com/promises-aplus/constructor-spec est une meilleure source.
    • Il suffit de pointer vers JavaScript Est la Promesse de Rappel exécuté Asynchronosuly 🙂
    • oh chouette! J'ai complètement oublié que je vais ajouter un lien vers la grâce.
    • Parfait. Merci beaucoup.
    • Est l'assignation de l' new Promise à une variable (var p) nécessaire?
    • non, il n'est là que comme une démarche didactique pour montrer que vous obtenez la promesse de retour et on peut l'utiliser comme une promesse. Il n'est pas nécessaire, mais je ne peux pas vraiment penser à ce que vous pouvez accomplir sans l'aide de la réelle promesse d'une certaine façon.
    • ahh, ok - merci!
    • Si vous avez de multiples promesses, il semble que cette méthode fonctionne tous ensemble, car en appelant var p = new Promise, la promesse commence son exécution. On dirait que vous êtes la synchronisation de leur résolution (fin de l'exécution) de ne pas le début de l'exécution.
    • Il devrait être de la partie de la Promesse de l'API avec le spécial de l'etat.
    • il sert à être (il ya longtemps), mais il a été changé à la révélation de constructeur modèle (qui a été considéré comme plus sûr). J'ai utilisé pour l'aimer - mais avec le recul je ne suis pas sûr que c'est plus sûr en fait - c'est juste un compromis. Vous pouvez lire à ce sujet ici: blog.dominique.moi/le-révéler-constructeur-modèle - de plus, si vous vous sentez passionnément à ce sujet (après avoir lu les documents de cours) - vous êtes les bienvenus pour faire une suggestion à TC39 pour introduire une autre API.

    InformationsquelleAutor Benjamin Gruenbaum
  2. 35

    Je veux ajouter mes 2 cents ici. Considérant exactement la question "la Création d'un es6 Promesse, sans commencer à le résoudre" je l'ai résolu de la création d'une fonction wrapper et l'appel de la fonction wrapper à la place. Code:

    Disons que nous avons une fonction f qui renvoie une Promesse

    /** @return Promise<any> */
function f(args) {
   return new Promise(....)
}

//calling f()
f('hello', 42).then((response) => { ... })

    Maintenant, je veux préparer un appel à f('hello', 42) sans vraiment le résoudre: 

    const task = () => f('hello', 42) //not calling it actually

//later
task().then((response) => { ... })

    Espère que cela va aider quelqu'un 🙂

    Référencement Promise.all() comme demandé dans les commentaires (et a répondu par @Joe Frambach), si je veux préparer un appel à f1('super') & f2('rainbow'), 2 fonctions qui retournent des promesses

    const f1 = args => new Promise( ... )
const f2 = args => new Promise( ... )

const tasks = [
  () => f1('super'),
  () => f2('rainbow')
]

//later
Promise.all(tasks.map(t => t()))
  .then(resolvedValues => { ... })
    • Vous méritez plus de points.
    • Comment cela peut-il être utilisé avec Promise.all() ?
    • tâches = [() => f(1), () => f(2)]; Promesse.tous(tâches.carte(t => t())).puis(...
    InformationsquelleAutor Manu
  3. 3

    Comment sur une approche plus globale?

    Vous pourriez écrire un Constructeur qui renvoie une nouvelle Promesse décorées avec .resolve() et .reject() méthodes.

    Vous serait probablement choisir de nommer le constructeur Deferred - terme avec beaucoup de préséance dans [l'histoire de] javascript promesses.

    function Deferred(fn) {
    fn = fn || function(){};

    var resolve_, reject_;

    var promise = new Promise(function(resolve, reject) {
        resolve_ = resolve;
        reject_ = reject;
        fn(resolve, reject);
    });

    promise.resolve = function(val) {
        (val === undefined) ? resolve_() : resolve_(val);
        return promise;//for chainability
    }
    promise.reject = function(reason) {
        (reason === undefined) ? reject_() : reject_(reason);
        return promise;//for chainability
    }
    promise.promise = function() {
        return promise.then(); //to derive an undecorated promise (expensive but simple).
    }

    return promise;
}

    En retournant décoré de la promsie plutôt qu'un simple objet, toutes les promesses naturel de méthodes/propriétés restent disponibles en plus à la décoration.

    Aussi, par la manipulation fn, révèle le motif reste disponible, si vous avez besoin d'/choisissez de l'utiliser sur un Différés.

    DÉMO

    Maintenant, avec la Deferred() utilitaire en place, votre code est quasiment identique à celle de jQuery exemple.

    var deferreds = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return deferreds[key].promise();
  }
  var def = Deferred();    
  deferreds[key] = def;
  return def.promise();
}
    • Je ne sais pas, ce qui semble re-présenter toutes les choses que nous voulions éviter lors de la commutation de deferreds à des promesses et le constructeur approche. Aussi, votre application est totalement trop compliqué, et contient quelques erreurs: a) si vous donnez Deferred un rappel paramètre, il devrait être rappelé à l'différé b) test de la value/reason pour undefined est absolument inutile c) .resolve et .reject jamais besoin d'être enchaînés d) votre .promise méthode ne retourne pas une promesse non
    • J'ai toujours été mal à l'aise sur la conception de sortir Deferreds. Je suis sûr qu'ils sont rares, mais il doit y avoir des cas d'utilisation lorsqu'un Différé est nécessaire - à-dire lorsque les moyens de règlement ne peut pas être défini à la fois une Promesse est créé. Je ne comprends pas (un), je suis ouvert à la persuasion sur (b) et vous avez certainement raison sur (c).
    • Je veux dire que vous devez faire fn(promise) (ou plutôt, fn(deferred) en fait) au lieu de fn(resolve, reject). Oui, je peux certainement voir un besoin de "resolver " objets" qui peuvent être stockées quelque part et exposer .fulfill et .reject méthodes, mais je pense que ceux qui ne devrait pas mettre en œuvre la promesse de l'interface.
    • Je comprends que jQuery, par exemple, révèle le report de lui-même comme un rappel de l'arg. J'ai peut-être raté quelque chose mais je ne vois pas pourquoi un Différé de mise en œuvre de ne pas imiter, de facto, pratique pour new Promise(fn) de révéler juste resolve et reject.
    • Aussi, alors que le when.js documentation décourage l'utilisation de ses when.defer, il ne reconnaissez que in certain (rare) scenarios it can be convenient to have access to both the promise and it's associated resolving functions. Si cette affirmation est vrai, alors ce que je propose ci-dessus doit être raisonnable (dans de rares scénarios).
    • Je pense juste que vous juste ne devriez pas faire les deux. Soit vous retournez un différé qui expose le résolveur de fonctions que les méthodes et la promesse (comme c'est parfois pratique en effet), ou vous utilisez la norme de pratique de l'passant séparé resolve et reject fonction de callback. Si vous voulez vraiment faire les deux deferreds et un rappel, s'il vous plaît au moins, ne pas mélanger les approches, et de suivre de jQuery exemple de passer le report de la fermeture de la portée.
    • Eh bien, c'est toute la nourriture pour la pensée et vous ne semblent arrêter de dire que ce que je propose ici est faux.
    • Oui, après que vous avez fixé l'erreur avec la .promise() méthode, la solution n'est plus mal, mais je ne pense qu'il n'est pas utile. Il va à l'encontre de mon idée subjective de bonnes pratiques.
    • Oui, j'ai fixé le .promise() méthode déjà.
    • Où est le promises variable déclarée? Ce qu'il détient?
    • le démo devrait suffire à l'expliquer.

    InformationsquelleAutor Roamer-1888