Wie kann ich feststellen, ob ein Objekt ein Versprechen ist?

Ob es sich um ein ES6-Versprechen oder ein Bluebird-Versprechen, ein Q-Versprechen usw. handelt.

Wie teste ich, ob ein bestimmtes Objekt ein Versprechen ist?

Wie eine Versprechensbibliothek entscheidet

Wenn es eine .thenFunktion hat, ist dies die einzige Standardversprechen-Bibliothek, die verwendet wird.

Die Promises / A + -Spezifikation hat einen Begriff namens thenable, der im Grunde "ein Objekt mit einer thenMethode" ist. Versprechen werden und sollten alles mit einer Dann-Methode aufnehmen. Alle von Ihnen erwähnten Versprechen-Implementierungen tun dies.

Wenn wir uns die Spezifikation ansehen :

2.3.3.3 Wenn thenes sich um eine Funktion handelt, rufen Sie sie mit x wie folgt auf: erstes Argument resolvePromise und zweites Argument reversePromise

Außerdem werden die Gründe für diese Entwurfsentscheidung erläutert:

Diese Behandlung von thenFähigkeiten ermöglicht die Interoperation von Versprechen-Implementierungen, solange sie eine Promises / A + -konforme thenMethode offenlegen . Es ermöglicht Promises / A + -Implementierungen auch, nicht konforme Implementierungen mit angemessenen Methoden zu „assimilieren“.

Wie solltest du dich entscheiden?

Sie sollten nicht - stattdessen nennen Promise.resolve(x)( Q(x)in Q) , die wird immer einen beliebigen Wert oder externe umwandeln thenkönnen in einer vertrauenswürdigen Versprechen. Es ist sicherer und einfacher, als diese Überprüfungen selbst durchzuführen.

Müssen Sie wirklich sicher sein?

Sie können es jederzeit über die Testsuite ausführen : D.

Wenn Sie überprüfen, ob etwas versprochen wird, wird der Code unnötig kompliziert. Verwenden Sie einfach Promise.resolve

Promise.resolve(valueOrPromiseItDoesntMatter).then(function(value) {

})

Hier ist meine ursprüngliche Antwort, die seitdem in der Spezifikation als Test für ein Versprechen bestätigt wurde:

Promise.resolve(obj) == obj

Dies funktioniert, weil der Algorithmus explizit verlangt, dass Promise.resolvedas genaue übergebene Objekt genau dann zurückgegeben werden muss, wenn es nach der Definition der Spezifikation ein Versprechen ist.

Ich habe hier eine andere Antwort, die dies früher sagte, aber ich habe sie in etwas anderes geändert, als es zu diesem Zeitpunkt mit Safari nicht funktionierte. Das war vor einem Jahr und das funktioniert jetzt auch in Safari zuverlässig.

Ich hätte meine ursprüngliche Antwort bearbeitet, außer das fühlte sich falsch an, da inzwischen mehr Menschen für die geänderte Lösung in dieser Antwort gestimmt haben als für das Original. Ich glaube, das ist die bessere Antwort, und ich hoffe, Sie stimmen zu.

Update: Dies ist nicht mehr die beste Antwort. Bitte stimmen Sie stattdessen meine andere Antwort ab .

obj instanceof Promise

Sollte es tun. Beachten Sie, dass dies möglicherweise nur mit nativen es6-Versprechungen zuverlässig funktioniert.

Wenn Sie eine Unterlegscheibe, eine Versprechensbibliothek oder etwas anderes verwenden, das vorgibt, wie ein Versprechen zu sein, ist es möglicherweise besser, auf ein "thenable" (alles mit einer .thenMethode) zu testen , wie in anderen Antworten hier gezeigt.

if (typeof thing.then === 'function') {
    // probably a promise
} else {
    // definitely not a promise
}

Um zu sehen, ob das angegebene Objekt ein ES6-Versprechen ist , können wir dieses Prädikat verwenden:

function isPromise(p) {
  return p && Object.prototype.toString.call(p) === "[object Promise]";
}

Calling toStringdirekt von den Object.prototypeRenditen einer nativen Stringdarstellung des Objekttypen gegeben , das ist "[object Promise]"in unserem Fall. Dies stellt sicher, dass das gegebene Objekt

• Umgeht falsch positive Ergebnisse wie ..:
  • Selbstdefinierter Objekttyp mit demselben Konstruktornamen ("Promise").
  • Selbstgeschriebene toStringMethode des gegebenen Objekts.
• Funktioniert in mehreren Umgebungskontexten (z. B. Iframes) im Gegensatz zuinstanceof oder isPrototypeOf.

Jedes bestimmte Hostobjekt , dessen Tag über geändert wurdeSymbol.toStringTag , kann jedoch zurückkehren "[object Promise]". Dies kann je nach Projekt das beabsichtigte Ergebnis sein oder auch nicht (z. B. wenn eine benutzerdefinierte Promise-Implementierung vorhanden ist).

Um festzustellen, ob das Objekt aus einem nativen ES6-Versprechen stammt , können wir Folgendes verwenden:

function isNativePromise(p) {
  return p && typeof p.constructor === "function"
    && Function.prototype.toString.call(p.constructor).replace(/\(.*\)/, "()")
    === Function.prototype.toString.call(/*native object*/Function)
      .replace("Function", "Promise") // replacing Identifier
      .replace(/\(.*\)/, "()"); // removing possible FormalParameterList 
}

Gemäß diesem und diesem Abschnitt der Spezifikation sollte die Zeichenfolgendarstellung der Funktion sein:

"Funktion Identifier ( Formale _opt ) { FunctionBody }"

was oben entsprechend behandelt wird. Der FunctionBody befindet sich [native code]in allen gängigen Browsern.

MDN: Function.prototype.toString

Dies funktioniert auch in mehreren Umgebungskontexten.

Keine Antwort auf die vollständige Frage, aber ich denke, es ist erwähnenswert, dass in Node.js 10 eine neue Util-Funktion namens aufgerufen isPromisewurde, die prüft, ob ein Objekt ein natives Versprechen ist oder nicht:

const utilTypes = require('util').types
const b_Promise = require('bluebird')

utilTypes.isPromise(Promise.resolve(5)) // true
utilTypes.isPromise(b_Promise.resolve(5)) // false

So erkennt das Paket graphql-js Versprechen:

function isPromise(value) {
  return Boolean(value && typeof value.then === 'function');
}

valueist der zurückgegebene Wert Ihrer Funktion. Ich verwende diesen Code in meinem Projekt und habe bisher kein Problem.

Hier ist das Codeformular https://github.com/ssnau/xkit/blob/master/util/is-promise.js

!!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';

Wenn ein Objekt mit einer thenMethode, sollte es als behandelt werden Promise.

Wenn Sie Typescript verwenden , möchte ich hinzufügen, dass Sie die Funktion "Typprädikat" verwenden können. Sie sollten nur die logische Überprüfung in eine Funktion einschließen, die zurückgibt, x is Promise<any>und Sie müssen keine Typecasts durchführen. Unten in meinem Beispiel cist entweder ein Versprechen oder einer meiner Typen, die ich durch Aufrufen der c.fetch()Methode in ein Versprechen umwandeln möchte .

export function toPromise(c: Container<any> | Promise<any>): Promise<any> {
    if (c == null) return Promise.resolve();
    return isContainer(c) ? c.fetch() : c;
}

export function isContainer(val: Container<any> | Promise<any>): val is Container<any> {
    return val && (<Container<any>>val).fetch !== undefined;
}

export function isPromise(val: Container<any> | Promise<any>): val is Promise<any> {
    return val && (<Promise<any>>val).then !== undefined;
}

Weitere Informationen: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Wenn Sie sich in einer asynchronen Methode befinden, können Sie dies tun und Unklarheiten vermeiden.

async myMethod(promiseOrNot){
  const theValue = await promiseOrNot()
}

Wenn die Funktion Versprechen zurückgibt, wartet sie mit dem aufgelösten Wert und kehrt zurück. Wenn die Funktion einen Wert zurückgibt, wird dieser als aufgelöst behandelt.

Wenn die Funktion heute kein Versprechen zurückgibt, aber morgen eines zurückgibt oder als asynchron deklariert wird, sind Sie zukunftssicher.

it('should return a promise', function() {
    var result = testedFunctionThatReturnsPromise();
    expect(result).toBeDefined();
    // 3 slightly different ways of verifying a promise
    expect(typeof result.then).toBe('function');
    expect(result instanceof Promise).toBe(true);
    expect(result).toBe(Promise.resolve(result));
});

Ich benutze diese Funktion als universelle Lösung:

function isPromise(value) {
  return value && value.then && typeof value.then === 'function';
}

Nachdem ich nach einer zuverlässigen Methode gesucht hatte , um Async- Funktionen oder sogar Versprechen zu erkennen , verwendete ich den folgenden Test:

() => fn.constructor.name === 'Promise' || fn.constructor.name === 'AsyncFunction'

ES6:

const promise = new Promise(resolve => resolve('olá'));

console.log(promise.toString().includes('Promise')); //true