Як дізнатися, чи є об'єкт Обіцянкою?

Будь то обіцянка ES6 чи обіцянка синьої пташки, обіцянка Q тощо.

Як перевірити, чи є даний об'єкт Обіцянням?

Як вирішує бібліотека обіцянок

Якщо у нього є .thenфункція - це єдине стандартне використання бібліотек з обіцянками.

Специфікація Promises / A + має поняття, яке називається " thenздатне", яке в основному є "об'єктом з thenметодом". Обіцянки будуть і повинні засвоювати що завгодно тодішнім методом. Усі згадані вами обіцянки виконують це.

Якщо ми подивимось на специфікацію :

2.3.3.3, якщо thenце функція, викликайте її з x як це, перший аргумент разрешитьPromise, а другий аргумент відхилитиPromise

Він також пояснює обґрунтування цього дизайнерського рішення:

Ця обробка можливостей thenдозволяє реалізовувати обіцянки взаємодіяти, якщо вони виявляють thenметод, що відповідає Promises / A + -compliant . Це також дозволяє реалізаціям Promises / A + "асимілювати" невідповідні реалізації з розумними методами.

Як слід вирішити

Ви не повинні - натомість дзвонити 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 обіцянками.

Якщо ви використовуєте шим, бібліотеку обіцянок або що-небудь інше, що претендує на подібність до обіцянки, то, можливо, буде більш доцільно протестувати на "Thenable" (що завгодно з .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]". Це може бути запланований результат або не залежно від проекту (наприклад, якщо є спеціальна реалізація обіцянок).

Щоб побачити, чи об’єкт з рідної 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 
}

Відповідно до цього та цього розділу специфікації, рядкове представлення функції має бути:

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

що обробляється відповідно вище. FunctionBody є[native code] у всіх основних браузерах.

MDN: Function.prototype.toString

Це працює також у різних середовищах.

Не відповідь на повне запитання, але я думаю, що варто згадати, що в Node.js 10 isPromiseбула додана нова утиліта, яка називається, яка перевіряє, чи об'єкт є власним Обіцянням чи ні:

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

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

Ось так, графікl-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методом, його слід трактувати як a 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';
}

Після пошуку надійного способу виявлення функцій Async або навіть Обіцянь я закінчив, використовуючи наступний тест:

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

ES6:

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

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