Como posso saber se um objeto é uma promessa?

Seja uma Promessa ES6 ou Promessa bluebird, Q Promise, etc.

Como faço para testar se um determinado objeto é uma promessa?

Como uma biblioteca de promessas decide

Se tiver uma .thenfunção - esse é o única padrão das bibliotecas de promessas.

A especificação Promises / A + possui uma noção chamada thencapaz, que é basicamente "um objeto com um thenmétodo". Promessas vão e devem assimilar qualquer coisa com um método then. Toda a implementação da promessa que você mencionou faz isso.

Se olharmos para a especificação :

2.3.3.3 se thenfor uma função, chame-a com x como este, primeiro argumento resolvePromise e segundo argumento rejectPromise

Também explica a justificativa para esta decisão de design:

Esse tratamento de capacidades thenpermite que as implementações de promessa interoperem, desde que exponham um thenmétodo compatível com Promises / A + . Ele também permite que as implementações do Promises / A + “assimilem” as implementações não conformes com métodos razoáveis.

Como você deve decidir

Você não deve - em vez disso, ligar Promise.resolve(x)( Q(x)em Q) que sempre converterá qualquer valor ou thencapacidade externa em uma promessa confiável. É mais seguro e fácil do que executar essas verificações você mesmo.

realmente precisa ter certeza?

Você sempre pode executá-lo no conjunto de testes : D

Para verificar se algo é promissor, complica desnecessariamente o código, basta usar Promise.resolve

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

})

Aqui está a minha resposta original, que foi ratificada na especificação como a maneira de testar uma promessa:

Promise.resolve(obj) == obj

Isso funciona porque o algoritmo exige explicitamente que Promise.resolvedeve retornar o objeto exato passado se e somente se for uma promessa pela definição da especificação.

Tenho outra resposta aqui, que costumava dizer isso, mas mudei para outra coisa quando não funcionava com o Safari naquele momento. Isso foi há um ano e agora isso funciona de maneira confiável, mesmo no Safari.

Eu teria editado minha resposta original, exceto a que parecia errada, já que agora mais pessoas votaram na solução alterada nessa resposta do que a original. Acredito que esta seja a melhor resposta e espero que você concorde.

Atualização: essa não é mais a melhor resposta. Por favor vote em minha outra resposta .

obj instanceof Promise

deve fazê-lo. Observe que isso só pode funcionar de maneira confiável com as promessas nativas do es6.

Se você estiver usando um calço, uma biblioteca de promessas ou qualquer outra coisa que pretenda ser semelhante a uma promessa, pode ser mais apropriado testar um "selecionável" (qualquer coisa com um .thenmétodo), conforme mostrado em outras respostas aqui.

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

Para ver se o objeto fornecido é uma promessa do ES6 , podemos fazer uso deste predicado:

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

Calling toStringdiretamente do Object.prototyperetorna uma representação de string nativa do tipo de objeto especificado, que está "[object Promise]"em nosso caso. Isso garante que o objeto fornecido

• Ignora falsos positivos, como ..:
  • Tipo de objeto auto-definido com o mesmo nome do construtor ("Promise").
  • toStringMétodo auto-escrito do objeto fornecido.
• Funciona em vários contextos de ambiente (por exemplo, iframes) em contraste cominstanceof ou isPrototypeOf.

No entanto, qualquer objeto host específico , que tenha sua tag modificada porSymbol.toStringTag , pode retornar "[object Promise]". Este pode ser o resultado pretendido ou não, dependendo do projeto (por exemplo, se houver uma implementação personalizada do Promise).

Para ver se o objeto é de uma promessa nativa do ES6 , 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 acordo com esta e esta seção da especificação, a representação de string da função deve ser:

" identificador da função ( formalParameterList _opt ) { FunctionBody }"

que é tratado em conformidade acima. O FunctionBody está [native code]em todos os principais navegadores.

MDN: Function.prototype.toString

Isso funciona em vários contextos de ambiente também.

Não é uma resposta para a pergunta completa, mas acho que vale a pena mencionar que no Node.js. 10 isPromisefoi adicionada uma nova função util chamada que verifica se um objeto é uma promessa nativa ou não:

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

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

É assim que o pacote graphql-js detecta promessas:

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

valueé o valor retornado da sua função. Estou usando esse código no meu projeto e não tenho nenhum problema até agora.

Aqui está o formulário 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';

se um objeto com um thenmétodo, ele deve ser tratado como um Promise.

Caso você esteja usando o Typecript , gostaria de acrescentar que você pode usar o recurso "predicado de tipo". Basta envolver a verificação lógica em uma função que retorne x is Promise<any>e você não precisará fazer previsões de digitação. Abaixo, no meu exemplo, chá uma promessa ou um dos meus tipos que desejo converter em promessa chamando o 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;
}

Mais informações: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Se você estiver em um método assíncrono, poderá fazer isso e evitar qualquer ambiguidade.

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

Se a função retornar promessa, aguardará e retornará com o valor resolvido. Se a função retornar um valor, ela será tratada como resolvida.

Se a função não retornar uma promessa hoje, mas amanhã retornar uma ou for declarada assíncrona, você estará à prova de 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));
});

Eu uso essa função como uma solução universal:

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

depois de procurar uma maneira confiável de detectar funções assíncronas ou até promessas , acabei usando o seguinte teste:

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

ES6:

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

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