Auslöser Versprechen, wenn ein Ereignis ausgelöst wird

Mein ganzes Projekt verwendet (Bluebird) Verspricht, aber es gibt eine bestimmte Bibliothek verwendet EventEmitter.

Will ich etwas erreichen, wie:

Promise.on('connect', function() {
    x.doSomething();
}).then(function() {
    return new Promise(function(resolve) {
        y.doAction(resolve); //this will result in `eventB` getting emitted
    });
}).on('eventB', function() {
    z.handleEventB();
}).then(function() {
    z.doSomethingElse();
});

Lese ich die Antwort auf EventEmitter in der Mitte eine Kette von Versprechungen.
Das gibt mir ein Weg zum ausführen der callback für 'connect' - Veranstaltung.
Hier ist, wo habe ich bisher

var p = new Promise(function(resolve) {
    emitter.on('connect', resolve);
});
p.on = function() {
    emitter.on.apply(emitter, arguments);
    return p;
};
p.on('connect', function() {
    x.doSomething();
}).then(function() {
    return new Promise(function(resolve) {
        y.doAction(resolve); //this will result in eventB getting emitted
    });
});

Nun, wie Kette weiter für 'eventB' ?

Vielleicht hilft: bahmutov.calepin.co/promisify-event-emitter.html
zwischengespeicherte version: web.archive.org/web/20160320100756/http://bahmutov.calepin.co/...

InformationsquelleAutor Jaydeep | 2015-04-29

  1. 18

    Ich nehme an, Sie wollen zu tun, eine andere Kette der Dinge für jede Veranstaltung. Auch wenn eventB ausgelöst wird, durch die Aktionen von connect, Sie können Sie behandeln wie einen anderen stream der Logik.

    Seite Hinweis: um Verwirrung Zu vermeiden-für dich und alle anderen, die dies Lesen codebase, würde ich empfehlen, gegen die Ergänzung verspricht mit zusätzlichen Methoden, es sei denn, Sie sind sehr gründlich zu dokumentieren.

    Durch Ihr Beispiel, wie es scheint, die folgenden funktionieren würde.

    var Promise = require( 'bluebird' )
var emitter = someEmitter()
var connected = new Promise( function( resolve ){
    emitter.on( 'connect', resolve )
})

var eventBHappened = new Promise( function( resolve ){
    emitter.on( 'eventB', resolve )
})

connected.then( function(){
    return x.doSomething()
}).then( function(){
    return y.doSomethingElse() //will trigger `eventB` eventually
})

//this promise stream will begin once `eventB` has been triggered
eventBHappened.then( function(){ 
    return z.doSomething()
})

    Wenn Sie möchten, um dies zu vereinfachen Konstante 

    var p = new Promise( function( resolve ){
    emitter.on( 'something', resolve )
})

    Können Sie so etwas wie das

    function waitForEvent( emitter, eventType ){
    return new Promise( function( resolve ){
        emitter.on( eventType, resolve )
    })
}

    Schaltet die code-Lösung, die oben in

    var Promise = require( 'bluebird' )
var emitter = someEmitter()

function waitForEvent( eventEmitter, eventType ){
    return new Promise( function( resolve ){
        eventEmitter.on( eventType, resolve )
    })
}

waitForEvent( emitter, 'connect' ).then( function(){
    return x.doSomething()
}).then( function(){
    return y.doSomethingElse() //will trigger `eventB` eventually
})

//this promise stream will begin once `eventB` has been triggered
waitForEvent( emitter, 'eventB' ).then( function(){ 
    return z.doSomething()
})

    Und da Funktionen in Javascript erfassen der Gültigkeitsbereich, in dem Sie definiert wurden, dieser code kann weiter vereinfacht werden zu

    var Promise = require( 'bluebird' )
var emitter = someEmitter()

function waitForEvent( type ){
    return new Promise( function( resolve ){
        //emitter has been captured from line #2
        emitter.on( type, resolve ) 
    })
}

waitForEvent( 'connect' ).then( function(){
    return x.doSomething()
}).then( function(){
    return y.doSomethingElse() //will trigger `eventB` eventually
})

//this promise stream will begin once `eventB` has been triggered
waitForEvent( 'eventB' ).then( function(){ 
    return z.doSomething()
})
    JoshWillik, vielen Dank für deine Hilfe 🙂
    Kann nicht Versprechen nur gelöst werden, wenn? Ich glaube nicht, dass das funktionieren würde für multi-Ereignis-APIs.
    du hast Recht. Wenn Sie hören müssen, um ein Ereignis mehrere Male, sind Sie nicht das richtige Werkzeug,
    verwenden .once statt .on dieser Weg, wenn ein Ereignis ausgelöst wird, mehr als einmal, es wird nicht brechen Ihre Versprechen (natürlich mit Betreuung)
    Sie können rufen Sie resolve() im inneren ein Versprechen mehrere Male, aber .once ist immer noch eine gute Idee, da was auf die Versprechen, die Auflösung wird immer nur der erste Wert, den es aufgelöst wird.

    InformationsquelleAutor JoshWillik

  2. 1

    Stand ich mit dem gleichen problem, und schrieb eine kleine Versprechen-wrapping-Bibliothek ( kontrolliert-Versprechen ), die es erlaubt promisify event-Strahler. Die Lösung für dein Beispiel:

    const Promise = require('bluebird');
const ControlledPromise = require('controlled-promise');

const emitter = someEmitter();
const waiting = new ControlledPromise();

function waitForEvent(type) {
    return waiting.call(() => {
       emitter.once(type, event => waiting.resolve(event));
    });
}

waitForEvent('connect')
    .then(() => x.doSomething())
    .then(() => waitForEvent('eventB'))
    .then(() => z.doSomethingElse());

    Die Vorteile eines solchen Ansatzes:

    • automatische RÜCKFÜHRUNG der bestehenden Versprechen, während es anhängig ist
    • einfachen Zugang zu resolve() /reject() Rückrufe

    InformationsquelleAutor vitalets

Schreibe einen Kommentar