如何判断一个对象是否是 Promise？

Question

无论是 ES6 Promise 还是 bluebird Promise、Q Promise 等

如何测试给定对象是否是 Promise？

Answer 1

promise 库如何决定

如果它有一个.then 函数 - 那是唯一标准承诺库使用。

Promises/A+ 规范有一个称为thenable 的概念，它基本上是“具有then 方法的对象”。 Promise 将并且应该使用 then 方法来吸收任何东西。您提到的所有承诺实现都是这样做的。

如果我们查看specification：

2.3.3.3 如果then是一个函数，用x作为this，第一个参数resolvePromise，第二个参数rejectPromise调用它

它还解释了此设计决策的基本原理：

这种对thenables 的处理允许promise 实现互操作，只要它们公开符合Promises/A+ 的then 方法。它还允许 Promises/A+ 实现使用合理的 then 方法“吸收”不符合要求的实现。

你应该如何决定

您不应该 - 而是调用 Promise.resolve(x)（Q 中的 Q(x)），这将始终将任何值或外部 thenable 转换为可信任的承诺。这比自己执行这些检查更安全、更容易。

真的需要确定吗？

您始终可以通过the test suite 运行它：D

Answer 2

检查是否有承诺会使代码不必要地复杂化，只需使用Promise.resolve

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

})

Answer 3

免责声明：不是更新 OP 的好答案，是每个库的，并且不能跨领域工作。改为检查.then。

这个答案，based on the spec 是一种测试仅在某些时候有效的承诺的方法，仅供参考。

Promise.resolve(obj) == obj &&
BLUEBIRD.resolve(obj) == obj

这是因为algorithm 明确要求Promise.resolve 必须返回传入的确切对象，如果并且仅当这是一个承诺由这个构造函数创建。

Answer 4

免责声明：不是更新 OP 的好答案，仅适用于本机，不适用于跨领域。请关注accepted answer。

obj instanceof Promise

应该这样做。请注意，这可能仅适用于原生 es6 承诺。

如果您正在使用 shim、promise 库或任何其他伪装成类似 promise 的东西，那么测试“thenable”（任何带有.then 方法的东西）可能更合适，如其他答案在这里。

Answer 5

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

Answer 6

要查看给定的对象是否是 ES6 Promise，我们可以使用这个谓词：

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

Calling toString 直接从Object.prototype 返回给定对象类型的native string representation，在我们的例子中是"[object Promise]"。这确保了给定的对象

• 绕过误报，例如..：
  • 具有相同构造函数名称（“Promise”）的自定义对象类型。
  • 给定对象的自写toString方法。
• 适用于多个环境上下文（例如 iframe）in contrast to instanceof 或 isPrototypeOf。

但是，任何具有tag modified via Symbol.toStringTag 的特定host object 都可以返回"[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 
}

根据规范的this和this section，函数的字符串表示应该是：

“函数标识符（FormalParameterList_opt）{FunctionBody}”

上面相应地处理。 FunctionBody 在所有主流浏览器中都是[native code]。

MDN: Function.prototype.toString

这也适用于多个环境上下文。

Answer 7

这是graphql-js 包检测承诺的方式：

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

value 是函数的返回值。我在我的项目中使用此代码，到目前为止没有问题。

Answer 8

不是完整问题的答案，但我认为值得一提的是，在 Node.js 10 中添加了一个名为 isPromise 的新 util 函数，用于检查对象是否为原生 Promise：

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

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

Answer 9

如果您使用异步方法，则可以这样做并避免任何歧义。

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

如果函数返回promise，它将等待并返回解析值。如果函数返回一个值，则将其视为已解析。

如果函数今天没有返回一个承诺，但明天返回一个或被声明为异步，那么你将是面向未来的。

Answer 10

这里是代码形式https://github.com/ssnau/xkit/blob/master/util/is-promise.js

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

如果对象具有then 方法，则应将其视为Promise。

Answer 11

如果您使用的是 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

Answer 12

在寻找一种可靠的方法来检测异步函数甚至Promises之后，我最终使用了以下测试：

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

Answer 13

为了避免比较而将可能的同步 value 推送到 Promise.resolve(value) 的任何事情都会将您的代码变成原本可以避免的异步。有时你在那个阶段不想要它。您想知道在微任务队列中的一些较早解决方案对您造成影响之前评估的结果..？

一个人可能会喜欢；

var isPromise = x => Object(x).constructor === Promise;

我对照一些我能想到的边缘情况检查了它，它似乎有效。

isPromise(undefined);                                           // <- false
isPromise(null);                                                // <- false
isPromise(0);                                                   // <- false
isPromise("");                                                  // <- false
isPromise({});                                                  // <- false
isPromise(setTimeout);                                          // <- false
isPromise(Promise);                                             // <- false
isPromise(new Promise((v,x) => setTimeout(v,1000,"whatever"))); // <- true
isPromise(fetch('http://example.com/movies.json'));             // <- true

我还没有对照任何非本地图书馆检查它，但现在有什么意义呢？

Answer 14

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

Answer 15

我使用这个函数作为一个通用的解决方案：

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

Answer 16

const isPromise = (value) => {
  return !!(
    value &&
    value.then &&
    typeof value.then === 'function' &&
    value?.constructor?.name === 'Promise'
  )
}

至于我 - 这个检查更好，试试看

Answer 17

在 Angular 中：

import { isPromise } from '@angular/compiler/src/util';

if (isPromise(variable)) {
  // do something
}

J

Answer 18

使用这个库

https://www.npmjs.com/package/is-promise

import isPromise from 'is-promise';
 
isPromise(Promise.resolve());//=>true
isPromise({then:function () {...}});//=>true
isPromise(null);//=>false
isPromise({});//=>false
isPromise({then: true})//=>false

Answer 19

ES6：

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

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