Erstellen Sie ein (ES6) Versprechen, ohne es zu lösen

Verwendung von ES6 verspricht,, wie erstelle ich ein Versprechen ohne Definition der Logik für die Lösung? Hier ist ein einfaches Beispiel (einige Typoskript):

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 :(
}

Es ist leicht getan, mit anderen Versprechen Bibliotheken. JQuery Beispiel:

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

Nur so kann ich sehen, dies zu tun wäre, um zu speichern die lösen-Funktion entfernt irgendwo in die Versprechen der Testamentsvollstrecker aber das scheint chaotisch, und ich bin nicht sicher, es ist festgelegt, Wann genau diese Funktion ausgeführt wird - wird es immer ausgeführt, unmittelbar auf dem Bau?

Dank.

InformationsquelleAutor der Frage Barguast | 2015-06-26

  1. 49

    Gute Frage!

    Den resolver, der an die Versprechen Konstruktor absichtlich läuft synchron zur Unterstützung dieser Anwendungsfall:

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

    Dann zu einem späteren Zeitpunkt:

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

    Dem Grund das Versprechen Konstruktor gegeben wird, ist, dass:

    • In der Regel (aber nicht immer) die Auflösung der Logik ist gebunden an die Schöpfung.
    • Das Versprechen Konstruktor werfen, sicher und wandelt Ausnahmen zu Ablehnungen.

    Manchmal es passt nicht und für dass es den der resolver läuft synchron. Hier ist weitere Lektüre zu dem Thema.

    InformationsquelleAutor der Antwort Benjamin Gruenbaum

  2. 16

    Möchte ich hinzufügen meine 2 Cent hier. Angesichts genau dieser Frage "Erstellen eines es6 Versprechen, ohne es zu lösen" ich löste es, erstellen Sie eine wrapper-Funktion und der Aufruf der wrapper-Funktion statt. Code:

    Sagen wir, wir haben eine Funktion f gibt ein Versprechen

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

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

    Nun, ich will vorbereiten einen Anruf zu f('hello', 42) ohne tatsächlich die Lösung: 

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

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

    Hoffe, dies hilft jemand 🙂

    Verweisen auf Promise.all() als fragte in den Kommentaren (und beantwortet von @Joe Frambach), wenn ich wollen vorbereiten einen Anruf zu f1('super') & f2('rainbow') - 2-Funktionen, die Rückkehr verspricht -

    function f1(args) {
  return new Promise( ... )
}

function f2(args) {
  return new Promise( ... )
}

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

//later
Promise.all(tasks)
  .then(() => { ... })

    InformationsquelleAutor der Antwort Manu

  3. 3

    Wie wäre es mit einem umfassenderen Ansatz?

    Könnten Sie schreiben Sie einen Konstruktor, der gibt ein neues Versprechen, verziert mit .resolve() und .reject() Methoden.

    Würden Sie wahrscheinlich wählen, um den Namen des Konstruktors Deferred - ein Begriff mit viel Vorrang bei [der Geschichte von] javascript verspricht.

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

    Durch Rücksendung der verzierten promsie eher als ein schlichtes Objekt, all das Versprechen die natürlichen Eigenschaften/Methoden verfügbar bleiben, zusätzlich zu den Dekorationen.

    Auch, durch den Umgang mit fnder offenbarer Muster bleibt verfügbar, sollten Sie benötigen/verwenden, wählen Sie es auf eine Latente.

    DEMO

    Nun, mit der Deferred() - Dienstprogramm wird Ihr code ist praktisch identisch mit dem jQuery-Beispiel.

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

    InformationsquelleAutor der Antwort Roamer-1888

Schreibe einen Kommentar