Как мне узнать, является ли объект Обещанием?

Будь то ES6 Promise или Bluebird Promise, Q Promise и т. Д.

Как мне проверить, является ли данный объект Обещанием?

Как решает библиотека обещаний

Если у него есть .thenфункция - это единственное стандартное обещание, которое используют библиотеки.

В спецификации Promises / A + есть понятие, называемое thenable, которое по сути является «объектом с thenметодом». Обещания будут и должны ассимилировать что-либо с помощью метода then. Все реализации обещаний, которые вы упомянули, делают это.

Если мы посмотрим на спецификации :

2.3.3.3 Если thenэто функция, вызовите ее с x как this, первый аргумент resolPromise и второй аргумент rejectPromise

Это также объясняет обоснование этого проектного решения:

Такое обращение с thenвозможностями позволяет взаимодействиям обещаний взаимодействовать, если они предоставляют thenспособ, соответствующий Promises / A + . Это также позволяет реализациям Promises / A + «ассимилировать» несовместимые реализации разумными методами then.

Как вы должны решить

Вы не должны - вместо этого вызывать Promise.resolve(x)( Q(x)в Q), который всегда преобразует любое значение или внешнее thenсостояние в доверенное обещание. Это безопаснее и проще, чем выполнять эти проверки самостоятельно.

действительно нужно быть уверенным?

Вы всегда можете запустить его через набор тестов : D

Проверка того, что что-то обещает излишне усложняет код, просто используйте Promise.resolve

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

})

Вот мой оригинальный ответ, который с тех пор был утвержден в спецификации как способ проверки на обещание:

Promise.resolve(obj) == obj

Это работает, потому что алгоритм явно требует, Promise.resolveчтобы он возвращал точный переданный объект, если и только если это обещание по определению спецификации.

У меня здесь есть другой ответ, который раньше говорил это, но я изменил его на что-то другое, когда он не работал с Safari в то время. Это было год назад, и теперь это надежно работает даже в Safari.

Я бы отредактировал свой первоначальный ответ, за исключением того, что он был ошибочным, учитывая, что к настоящему моменту за это решение проголосовало больше людей, чем за оригинал. Я считаю, что это лучший ответ, и я надеюсь, что вы согласны.

Обновление: это больше не лучший ответ. Пожалуйста, проголосуйте за мой другой ответ .

obj instanceof Promise

должен сделать это. Обратите внимание, что это может надежно работать только с собственными обещаниями es6.

Если вы используете прокладку, библиотеку обещаний или что-то еще, притворяющееся подобным обещанию, тогда может быть более уместно проверить «жизнеспособность» (что-нибудь с .thenметодом), как показано в других ответах здесь.

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

Чтобы увидеть, является ли данный объект Обещанием ES6 , мы можем использовать этот предикат:

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

CallING toStringнепосредственно от Object.prototypeвозвращения в родную строковое представление данного типа объекта , который "[object Promise]"в нашем случае. Это гарантирует, что данный объект

• Обходит ложные срабатывания, такие как ..:
  • Определенный пользователем тип объекта с тем же именем конструктора («Обещание»).
  • Самописный toStringметод данного объекта.
• Работает в разных контекстах среды (например, в фреймах) в отличие отinstanceof или isPrototypeOf.

Однако любой конкретный хост-объект , тег которого был изменен с помощьюSymbol.toStringTag , может вернуться "[object Promise]". Это может быть ожидаемый результат или нет в зависимости от проекта (например, если есть пользовательская реализация Promise).

Чтобы увидеть, является ли объект родным ES6 Promise , мы можем использовать:

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 
}

Согласно этому и этому разделу спецификации, строковое представление функции должно быть:

" Идентификатор функции ( FormalParameterList _opt ) { FunctionBody }"

который обрабатывается соответственно выше. FunctionBody находится [native code]во всех основных браузерах.

MDN: Function.prototype.toString

Это работает в разных контекстах среды.

Не ответ на полный вопрос, но я думаю, что стоит упомянуть, что в Node.js 10 isPromiseбыла добавлена новая вызываемая функция, которая проверяет, является ли объект собственным Promise или нет:

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

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

Вот как пакет graphql-js обнаруживает обещания:

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

valueВозвращаемое значение вашей функции. Я использую этот код в своем проекте, и у меня пока нет проблем.

Вот кодовая форма https://github.com/ssnau/xkit/blob/master/util/is-promise.js

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

если объект с thenметодом, он должен рассматриваться как Promise.

Если вы используете Typescript , я хотел бы добавить, что вы можете использовать функцию «предиката типа». Просто следует обернуть логическую проверку в функцию, которая возвращает, x is Promise<any>и вам не нужно будет делать типы типов. Ниже на моем примере cприведено либо обещание, либо один из моих типов, которые я хочу преобразовать в обещание путем вызова c.fetch()метода.

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

Дополнительная информация: https://www.typescriptlang.org/docs/handbook/advanced-types.html.

Если вы используете асинхронный метод, вы можете сделать это и избежать двусмысленности.

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

Если функция возвращает обещание, она будет ожидать и возвращаться с разрешенным значением. Если функция возвращает значение, оно будет считаться разрешенным.

Если функция не возвращает обещание сегодня, но завтра возвращает одно или объявляется как асинхронное, вы будете ориентированы на будущее.

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

Я использую эту функцию как универсальное решение:

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

после поиска надежного способа обнаружения асинхронных функций или даже обещаний , я использовал следующий тест:

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

ES6:

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

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