Gibt es noch Gründe, Versprechensbibliotheken wie Q oder BlueBird zu nutzen, nachdem wir ES6-Versprechen haben?

Dem alten Sprichwort geht, dass Sie sollten wählen Sie das richtige Werkzeug für den job. ES6 verspricht die Grundlagen liefern. Wenn alles, was Sie jemals wollen oder müssen, ist die Grundlagen, dann sollte/könnte gut funktionieren für Sie. Aber, es gibt mehr Werkzeuge in der Werkzeug bin, als nur die Grundlagen, und es gibt Situationen, in denen zusätzliche Werkzeuge sind sehr nützlich. Und ich würde argumentieren, dass ES6 Versprechungen sind, auch fehlen einige der Grundlagen wie promisification, die nützlich sind in so ziemlich jeder node.js Projekt.

Ich bin am meisten vertraut mit dem Bluebird Versprechen-Bibliothek so werde ich sprechen meist von meiner Erfahrung mit der Bibliothek.

So, hier sind meine top 6 Gründe, um eine weitere Lage Versprechen Bibliothek

1. Nicht Promisified asynchrone Schnittstellen - .promisify() und .promisifyAll() sind unglaublich nützlich, um alle diejenigen, die asynchrone Schnittstellen, die noch erfordern plain Rückrufe und noch nicht Rendite verspricht - eine Zeile code erstellt eine promisified version einer ganzen Schnittstelle.

2. Schneller - Bluebird ist deutlich schneller als native verspricht in den meisten Umgebungen.

3. Sequenzierung von async-array-iteration - Promise.mapSeries() oder Promise.reduce() erlauben Sie Durchlaufen ein array, Aufruf einer asynchronen operation auf jedes element, aber die Sequenzierung des asynchronen Operationen, so dass Sie passieren, eine nach der anderen, nicht alle gleichzeitig. Sie können dies tun, entweder, weil die Ziel-server es verlangt oder weil man sich übergeben zu müssen, ein Ergebnis auf die nächste.

4. Polyfill - Wenn Sie möchten, verwenden Sie verspricht, die in älteren Versionen des browser-clients, benötigen Sie ein polyfill sowieso. Kann auch sein, daß sich eine Lage polyfill. Da node.js hat ES6 Versprechungen, die Sie nicht brauchen, ein polyfill in node.js aber Sie kann in einem browser. Wenn Sie Sie Kodieren beide node.js server und client kann es sehr nützlich sein, um die gleiche Versprechen-Bibliothek und-Funktionen (einfacher zum teilen von code, Kontext wechseln zwischen den Umgebungen, die Nutzung von gemeinsamen Codierung-Techniken für asynchrone code, etc...).

5. Weitere Nützliche Funktionen - Bluebird hat Promise.map()Promise.some()Promise.any()Promise.filter()Promise.each() und Promise.props() alle, die gelegentlich praktisch. Während diese Operationen können durchgeführt werden, mit ES6 verspricht und zusätzlichen code, Bluebird kommt mit diesen Vorgängen bereits vormontiert und vorgetestet, so ist es einfacher und weniger code, um Sie zu benutzen.

6. Eingebaute Warnungen und Full-Stack-Traces - Bluebird hat eine Reihe von eingebauten Warnungen, die Sie warnen, um Probleme, die wahrscheinlich der code falsch oder ist das ein bug. Zum Beispiel, wenn Sie eine Funktion aufrufen, erstellt ein neues Versprechen, innerhalb einer .then() handler ohne Rückkehr, die Versprechen (für die Verbindung in das aktuelle Versprechen Kette), dann in den meisten Fällen, das ist ein unbeabsichtigter Fehler und Bluebird wird Ihnen eine Warnung zu diesen Effekt. Andere built-in-Bluebird Warnungen sind hier beschrieben.

Hier einige weitere Details über diese verschiedenen Themen:

PromisifyAll

In jedem node.js Projekt, habe ich sofort verwenden Bluebird überall, weil ich .promisifyAll() viel auf standard node.js Module wie fs Modul.

Node.js nicht allein ein Versprechen Schnittstelle zu den integrierten Modulen, die async-IO-wie die fs Modul. Also, wenn Sie wollen, verwenden Sie verspricht, mit denen die Schnittstellen, die Sie sind Links, um entweder hand-code ein Versprechen wrapper für jedes Modul die Funktion, die Sie verwenden oder Holen Sie sich eine Bibliothek, die das tun können, für die Sie oder nicht nutzen verspricht.

Bluebird ist Promise.promisify() und Promise.promisifyAll() sorgen für eine automatische Verpackung von node.js Aufrufkonvention async APIs, um die Rückkehr verspricht. Es ist sehr nützlich und spart Zeit. Ich benutze es die ganze Zeit.

Hier ist ein Beispiel, wie das funktioniert:

const Promise = require('bluebird');
const fs = Promise.promisifyAll(require('fs'));

fs.readFileAsync('somefile.text').then(function(data) {
   //do something with data here
});

Die alternative wäre, manuell erstellen Sie Ihre eigenen Versprechen-wrapper für jedes fs API, die Sie verwenden wollte:

const fs = require('fs');

function readFileAsync(file, options) {
    return new Promise(function(resolve, reject) {
        fs.readFile(file, options, function(err, data) {
            if (err) {
                reject(err);
            } else {
                 resolve(data);
            }
        });
    });
}

readFileAsync('somefile.text').then(function(data) {
   //do something with data here
});

Und Sie haben, um manuell tun Sie dies für jede API-Funktion, die Sie verwenden möchten. Das ist eindeutig nicht sinnvoll. Es ist boilerplate code. Sie könnte genauso gut bekommen ein Dienstprogramm, das macht diese Arbeit für Sie. Bluebird ist Promise.promisify() und Promise.promisifyAll() sind so ein utility.

Weitere Nützliche Funktionen

Hier sind einige der Bluebird features, die ich ganz nützlich finden (es gibt ein paar code-Beispiele weiter unten, wie Sie diese speichern können code oder die Geschwindigkeit der Entwicklung):

Promise.promisify()
Promise.promisifyAll()
Promise.map()
Promise.reduce()
Promise.mapSeries()
Promise.delay()

Neben seiner nützlichen Funktion, Promise.map() unterstützt auch eine Parallelität option können Sie angeben, wie viele Operationen erlaubt sein sollte, ausgeführt werden, zur gleichen Zeit, die ist besonders nützlich, wenn Sie eine Menge von etwas zu tun, kann aber nicht überwältigen einige externe Ressourcen.

Einige von diese können sowohl sogenannte stand-alone-und auf ein Versprechen, das sich löst, um eine iterierbar, die sparen eine Menge code.

---

Polyfill

In einem browser-Projekt, da Sie in der Regel wollen noch unterstützen einige Browser, die das nicht haben, Versprechen Unterstützung, die Sie am Ende brauchen einen polyfill sowieso. Wenn du auch mit jQuery, können Sie manchmal nutzen Sie einfach das Versprechen, bieten integrierte Unterstützung für jQuery (obwohl es schmerzlich nicht-standard-in mancher Hinsicht vielleicht behoben, jQuery 3.0), aber wenn das Projekt beinhaltet jede erhebliche asynchrone Aktivität, finde ich die erweiterten Funktionen in Bluebird sehr nützlich.

---

Schneller

Ist auch erwähnenswert, dass Bluebird verspricht zu sein scheinen deutlich schneller als die Versprechungen gebaut in V8. Sehen dieser Beitrag weitere Diskussion zu diesem Thema.

---

Eine Große Sache Node.js Fehlt

Was würde mir überlegen mit Bluebird weniger node.js die Entwicklung wäre, wenn node.js gebaut in einer promisify-Funktion, so dass Sie könnte so etwas wie dieses:

const fs = requirep('fs');

fs.readFileAsync('somefile.text').then(function(data) {
   //do something with data here
});

Oder einfach nur bieten bereits promisified Methoden als Teil der integrierten Module.

Bis dann, ich mache das mit Bluebird:

const Promise = require('bluebird');
const fs = Promise.promisifyAll(require('fs'));

fs.readFileAsync('somefile.text').then(function(data) {
   //do something with data here
});

Scheint es ein wenig seltsam zu haben ES6 Versprechen Unterstützung node.js und keine der eingebauten Module, die Rendite verspricht. Dies muss sortiert in node.js. Bis dann, ich benutze Bluebird zu promisify ganze Bibliotheken. Also, es fühlt sich an wie verspricht werden etwa 20% umgesetzt node.js nun, da keiner von den built-in-Module ermöglichen es Ihnen nutzen verspricht, mit Ihnen ohne manuell wickeln Sie es zuerst.

---

Beispiele

Hier ist ein Beispiel von schlichtem Verspricht vs. Bluebird ist promisify und Promise.map() für das Lesen eine Reihe von Dateien in parallelen und Benachrichtigen, wenn Sie fertig mit allen Daten:

Plain Verspricht

const files = ["file1.txt", "fileA.txt", "fileB.txt"];
const fs = require('fs');

//make promise version of fs.readFile()
function fsReadFileP(file, options) {
    return new Promise(function(resolve, reject) {
        fs.readFile(file, options, function(err, data) {
            if (err) return reject(err);
            resolve(data);
        });
    });
}


Promise.all(files.map(fsReadFileP)).then(function(results) {
    //files data in results Array
}, function(err) {
    //error here
});

Bluebird Promise.map() und Promise.promisifyAll()

const Promise = require('bluebird');
const fs = Promise.promisifyAll(require('fs'));
const files = ["file1.txt", "fileA.txt", "fileB.txt"];

Promise.map(files, fs.readFileAsync).then(function(results) {
    //files data in results Array
}, function(err) {
    //error here
});

---

Hier ist ein Beispiel von schlichtem Verspricht vs. Bluebird ist promisify und Promise.map() beim Lesen eine Reihe von URLs, die von einem remote-host, auf dem Sie Lesen können, höchstens 4 in einer Zeit, möchten aber weiterhin so viele Anfragen parallel als erlaubt:

Plain JS Verspricht

const request = require('request');
const urls = [url1, url2, url3, url4, url5, ....];

//make promisified version of request.get()
function requestGetP(url) {
    return new Promise(function(resolve, reject) {
        request.get(url, function(err, data) {
            if (err) return reject(err);
            resolve(data);
        });
    });
}

function getURLs(urlArray, concurrentLimit) {
    var numInFlight = 0;
    var index = 0;
    var results = new Array(urlArray.length);
    return new Promise(function(resolve, reject) {
        function next() {
            //load more until concurrentLimit is reached or until we got to the last one
            while (numInFlight < concurrentLimit && index < urlArray.length) {
                (function(i) {
                    requestGetP(urlArray[index++]).then(function(data) {
                        --numInFlight;
                        results[i] = data;
                        next();
                    }, function(err) {
                        reject(err);
                    });
                    ++numInFlight;
                })(index);
            }
            //since we always call next() upon completion of a request, we can test here
            //to see if there was nothing left to do or finish
            if (numInFlight === 0 && index === urlArray.length) {
                resolve(results);
            }
        }
        next();
    });
}

Bluebird Verspricht

const Promise = require('bluebird');
const request = Promise.promisifyAll(require('request'));
const urls = [url1, url2, url3, url4, url5, ....];

Promise.map(urls, request.getAsync, {concurrency: 4}).then(function(results) {
    //urls fetched in order in results Array
}, function(err) {
    //error here
});

InformationsquelleAutor der Antwort jfriend00