How do I tell if an object is a Promise?

How do I tell if an object is a Promise?

Whether it’s an ES6 Promise or a bluebird Promise, Q Promise, etc.
How do I test to see if a given object is a Promise?

Solutions/Answers:

Solution 1:

How a promise library decides

If it has a .then function – that’s the only standard promise libraries use.

The Promises/A+ specification has a notion called thenable which is basically “an object with a then method”. Promises will and should assimilate anything with a then method. All of the promise implementation you’ve mentioned do this.

If we look at the specification:

2.3.3.3 if then is a function, call it with x as this, first argument resolvePromise, and second argument rejectPromise

It also explains the rationale for this design decision:

This treatment of thenables allows promise implementations to interoperate, as long as they expose a Promises/A+-compliant then method. It also allows Promises/A+ implementations to “assimilate” nonconformant implementations with reasonable then methods.

How you should decide

You shouldn’t – instead call Promise.resolve(x) (Q(x) in Q) that will always convert any value or external thenable into a trusted promise. It is safer and easier than performing these checks yourself.

Related:  How can I check whether a variable is defined in Node.js?

really need to be sure?

You can always run it through the test suite 😀

Solution 2:

Checking if something is promise unnecessarily complicates the code, just use Promise.resolve

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

})

Solution 3:

Here’s my original answer, which has since been ratified in the spec as the way to test for a promise:

Promise.resolve(obj) == obj

This works because the algorithm explicitly demands that Promise.resolve must return the exact object passed in if and only if it is a promise by the definition of the spec.

I have another answer here, which used to say this, but I changed it to something else when it didn’t work with Safari at that time. That was a year ago, and this now works reliably even in Safari.

I would have edited my original answer, except that felt wrong, given that more people by now have voted for the altered solution in that answer than the original. I believe this is the better answer, and I hope you agree.

Related:  How to remove only the parent element and not its child elements in JavaScript?

Solution 4:

Update: This is no longer the best answer. Please vote up my other answer instead.

obj instanceof Promise

should do it. Note that this may only work reliably with native es6 promises.

If you’re using a shim, a promise library or anything else pretending to be promise-like, then it may be more appropriate to test for a “thenable” (anything with a .then method), as shown in other answers here.

Solution 5:

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

Solution 6:

To see if the given object is a ES6 Promise, we can make use of this predicate:

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

Calling toString directly from the Object.prototype returns a native string representation of the given object type which is "[object Promise]" in our case. This ensures that the given object

  • Bypasses false positives such as..:
    • Self-defined object type with the same constructor name (“Promise”).
    • Self-written toString method of the given object.
  • Works across multiple environment contexts (e.g. iframes) in contrast to instanceof or isPrototypeOf.

However, any particular host object, that has its tag modified via Symbol.toStringTag, can return "[object Promise]". This may be the intended result or not depending on the project (e.g. if there is a custom Promise implementation).

Related:  how to use webpack to load CDN or external vendor javascript lib in js file, not in html file

To see if the object is from a native ES6 Promise, we can use:

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 
}

According to this and this section of the spec, the string representation of function should be:

“function Identifier ( FormalParameterListopt ) { FunctionBody }”

which is handled accordingly above. The FunctionBody is [native code] in all major browsers.

MDN: Function.prototype.toString

This works across multiple environment contexts as well.