Come faccio a sapere se un oggetto è una promessa?

Che si tratti di una promessa ES6 o di una promessa bluebird, una promessa Q, ecc.

Come posso verificare se un determinato oggetto è una promessa?

Come decide una biblioteca promessa

Se ha una .thenfunzione, questa è l' unica libreria standard utilizzata.

La specifica Promises / A + ha una nozione chiamata thencapace che è sostanzialmente "un oggetto con un thenmetodo". Le promesse saranno e dovrebbero assimilare qualsiasi cosa con un metodo allora. Tutte le implementazioni promesse che hai citato fanno questo.

Se guardiamo le specifiche :

2.3.3.3 se thenè una funzione, chiamala con x come questa, primo argomento resolPromise e secondo argomento rejectPromise

Spiega anche la logica di questa decisione progettuale:

Questo trattamento di thenables consente alle implementazioni promettenti di interagire, purché espongano un thenmetodo conforme a Promises / A + . Inoltre, consente alle implementazioni Promises / A + di "assimilare" le implementazioni non conformi con metodi ragionevoli.

Come dovresti decidere

Non dovresti - invece chiama Promise.resolve(x)( Q(x)in Q) che convertirà sempre qualsiasi valore o valore esterno thenin una promessa fidata. È più sicuro e più semplice che eseguire questi controlli da soli.

hai davvero bisogno di essere sicuro?

Puoi sempre eseguirlo attraverso la suite di test : D

Controllare se qualcosa è promettente complica inutilmente il codice, basta usare Promise.resolve

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

})

Ecco la mia risposta originale, che da allora è stata ratificata nelle specifiche come il modo per testare una promessa:

Promise.resolve(obj) == obj

Questo funziona perché l' algoritmo richiede esplicitamente che Promise.resolvedeve restituire l'oggetto esatto passato se e solo se è una promessa dalla definizione della specifica.

Ho un'altra risposta qui, che era solito dire questo, ma l'ho cambiata in qualcos'altro quando non funzionava con Safari in quel momento. È stato un anno fa e ora funziona in modo affidabile anche in Safari.

Avrei modificato la mia risposta originale, tranne che mi sembrava sbagliato, dato che ormai più persone hanno votato per la soluzione modificata in quella risposta rispetto all'originale. Credo che questa sia la risposta migliore e spero che tu sia d'accordo.

Aggiornamento: questa non è più la risposta migliore. Per favore, vota l'altra mia risposta .

obj instanceof Promise

dovrebbe farlo. Nota che questo può funzionare in modo affidabile solo con le promesse es6 native.

Se stai usando uno shim, una libreria di promesse o qualsiasi altra cosa che finge di essere simile a una promessa, allora potrebbe essere più appropriato testare un "allora" (qualsiasi cosa con un .thenmetodo), come mostrato in altre risposte qui.

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

Per vedere se l'oggetto indicato è una promessa ES6 , possiamo utilizzare questo predicato:

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

Calling toStringdirettamente dai Object.prototyperitorni una rappresentazione di stringa nativa del tipo di oggetto dato che è "[object Promise]"nel nostro caso. Questo assicura che l'oggetto dato

• Bypassa i falsi positivi come ..:
  • Tipo di oggetto auto-definito con lo stesso nome costruttore ("Promessa").
  • toStringMetodo auto-scritto dell'oggetto dato.
• Funziona in più contesti di ambiente (ad es. Iframe) in contrasto coninstanceof o isPrototypeOf.

Tuttavia, qualsiasi oggetto host particolare , che ha il tag modificato tramiteSymbol.toStringTag , può restituire "[object Promise]". Questo potrebbe essere il risultato desiderato o meno a seconda del progetto (ad esempio se esiste un'implementazione Promise personalizzata).

Per vedere se l'oggetto proviene da una Promessa ES6 nativa , possiamo usare:

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 
}

Secondo questa e questa sezione delle specifiche, la rappresentazione in formato stringa della funzione dovrebbe essere:

" Identificatore di funzione ( FormalParameterList _opt ) { FunctionBody }"

che è gestito di conseguenza sopra. Il FunctionBody è presente [native code]in tutti i principali browser.

MDN: Function.prototype.toString

Funziona anche in più contesti di ambiente.

Non è una risposta alla domanda completa, ma penso che valga la pena ricordare che in Node.js 10 è isPromisestata aggiunta una nuova funzione util chiamata che verifica se un oggetto è una Promessa nativa o meno:

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

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

Ecco come il pacchetto graphql-js rileva le promesse:

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

valueè il valore restituito della tua funzione. Sto usando questo codice nel mio progetto e finora non ho avuto problemi.

Ecco il modulo in codice https://github.com/ssnau/xkit/blob/master/util/is-promise.js

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

se un oggetto con un thenmetodo, dovrebbe essere trattato come a Promise.

Nel caso in cui si stia utilizzando Typescript , vorrei aggiungere che è possibile utilizzare la funzione "tipo predicato". Dovrei semplicemente racchiudere la verifica logica in una funzione che ritorna x is Promise<any>e non sarà necessario eseguire i caratteri tipografici. Sotto il mio esempio, cè una promessa o uno dei miei tipi che voglio convertire in una promessa chiamando il c.fetch()metodo.

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

Maggiori informazioni: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Se si utilizza un metodo asincrono, è possibile farlo ed evitare qualsiasi ambiguità.

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

Se la funzione restituisce promessa, attenderà e tornerà con il valore risolto. Se la funzione restituisce un valore, verrà trattata come risolta.

Se la funzione non restituisce una promessa oggi, ma domani ne restituisce una o viene dichiarata asincrona, sarai a prova di futuro.

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

Uso questa funzione come soluzione universale:

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

dopo aver cercato un modo affidabile per rilevare le funzioni asincrone o anche le promesse , ho finito con il seguente test:

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

ES6:

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

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