¿Cómo puedo saber si un objeto es una promesa?

Ya sea una promesa ES6 o una promesa Bluebird, Q Promise, etc.

¿Cómo pruebo para ver si un objeto dado es una promesa?

Cómo decide una biblioteca de promesas

Si tiene una .thenfunción, esa es la única promesa estándar que usan las bibliotecas.

La especificación Promesas / A + tiene una noción llamada thencapaz que es básicamente "un objeto con un thenmétodo". Las promesas harán y deberían asimilar cualquier cosa con un método de entonces. Toda la implementación de promesa que ha mencionado hace esto.

Si nos fijamos en la especificación :

2.3.3.3 si thenes una función, llámela con x como esto, primer argumento resolvePromise y segundo argumento acceptPromise

También explica la justificación de esta decisión de diseño:

Este tratamiento de thenables permite que las implementaciones de promesas interoperen, siempre que expongan un thenmétodo compatible con Promesas / A + . También permite que las implementaciones de Promises / A + "asimilen" implementaciones no conformes con métodos razonables.

Cómo deberías decidir

No debería, en su lugar, llamar Promise.resolve(x)( Q(x)en Q) que siempre convertirá cualquier valor o thencapacidad externa en una promesa confiable. Es más seguro y fácil que realizar estas comprobaciones usted mismo.

realmente necesita estar seguro?

Siempre puede ejecutarlo a través del conjunto de pruebas : D

Comprobar si algo es prometedor complica innecesariamente el código, solo use Promise.resolve

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

})

Aquí está mi respuesta original, que desde entonces ha sido ratificada en la especificación como la forma de probar una promesa:

Promise.resolve(obj) == obj

Esto funciona porque el algoritmo exige explícitamente que Promise.resolvedebe devolver el objeto exacto pasado si y solo si es una promesa según la definición de la especificación.

Tengo otra respuesta aquí, que solía decir esto, pero la cambié a otra cuando no funcionaba con Safari en ese momento. Eso fue hace un año, y ahora funciona de manera confiable incluso en Safari.

Habría editado mi respuesta original, excepto que se sintió mal, dado que ahora más personas han votado por la solución alterada en esa respuesta que la original. Creo que esta es la mejor respuesta, y espero que esté de acuerdo.

Actualización: esta ya no es la mejor respuesta. Por favor vote mi otra respuesta en su lugar.

obj instanceof Promise

Deberías hacerlo. Tenga en cuenta que esto solo puede funcionar de manera confiable con las promesas nativas de es6.

Si está utilizando una cuña, una biblioteca de promesas o cualquier otra cosa que pretenda ser como una promesa, entonces puede ser más apropiado hacer una prueba para un "thenable" (cualquier cosa con un .thenmétodo), como se muestra en otras respuestas aquí.

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

Para ver si el objeto dado es una promesa ES6 , podemos hacer uso de este predicado:

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

Calling toStringdirectamente del Object.prototypedevuelve una representación de cadena nativa del tipo de objeto dado que es "[object Promise]"en nuestro caso. Esto asegura que el objeto dado

• Omite falsos positivos como ..:
  • Tipo de objeto autodefinido con el mismo nombre de constructor ("Promesa").
  • toStringMétodo auto-escrito del objeto dado.
• Funciona en múltiples contextos de entorno (por ejemplo, iframes) en contraste coninstanceof o isPrototypeOf.

Sin embargo, cualquier objeto host particular , que tenga su etiqueta modificada a través deSymbol.toStringTag , puede regresar "[object Promise]". Este puede ser el resultado deseado o no dependiendo del proyecto (por ejemplo, si hay una implementación personalizada de Promise).

Para ver si el objeto es de una Promesa ES6 nativa , podemos usar:

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 
}

De acuerdo con esta y esta sección de la especificación, la representación de cadena de la función debe ser:

" Identificador de función ( FormalParameterList _opt ) { FunctionBody }"

que se maneja en consecuencia arriba. El FunctionBody es [native code]en todos los principales navegadores.

MDN: Function.prototype.toString

Esto también funciona en múltiples contextos de entorno.

No es una respuesta a la pregunta completa, pero creo que vale la pena mencionar que en Node.js 10 isPromisese agregó una nueva función de utilidad llamada que comprueba si un objeto es una Promesa nativa o no:

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

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

Así es como el paquete graphql-js detecta las promesas:

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

valuees el valor devuelto de su función. Estoy usando este código en mi proyecto y no tengo ningún problema hasta ahora.

Aquí está el formulario de código https://github.com/ssnau/xkit/blob/master/util/is-promise.js

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

si un objeto con un thenmétodo, debe tratarse como a Promise.

En caso de que esté utilizando Typecript , me gustaría agregar que puede usar la función "predicado de tipo". Solo debe envolver la verificación lógica en una función que regrese x is Promise<any>y no necesitará hacer typecasts. A continuación, en mi ejemplo, chay una promesa o uno de mis tipos que quiero convertir en una promesa llamando al c.fetch()método.

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

Más información: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Si utiliza un método asíncrono, puede hacerlo y evitar cualquier ambigüedad.

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

Si la función devuelve la promesa, esperará y volverá con el valor resuelto. Si la función devuelve un valor, se tratará como resuelto.

Si la función no devuelve una promesa hoy, pero mañana devuelve una o se declara asíncrona, estará preparado para el 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));
});

Yo uso esta función como una solución universal:

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

Después de buscar una forma confiable de detectar funciones asincrónicas o incluso promesas , terminé usando la siguiente prueba:

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

ES6:

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

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