Comment savoir si un objet est une promesse?

Qu'il s'agisse d'une promesse ES6 ou d'une promesse bluebird, d'une promesse Q, etc.

Comment puis-je tester pour voir si un objet donné est une promesse?

Comment une bibliothèque de promesses décide

S'il a une .thenfonction - c'est la seule promesse standard que les bibliothèques utilisent.

La spécification Promises / A + a une notion appelée thencapable qui est fondamentalement "un objet avec une thenméthode". Les promesses assimileront et devraient assimiler n'importe quoi avec une méthode alors. Toutes les mises en œuvre de promesses que vous avez mentionnées le font.

Si nous regardons la spécification :

2.3.3.3 si thenest une fonction, appelez-la avec x comme ceci, premier argument resolverPromise et deuxième argument rejettePromise

Il explique également la justification de cette décision de conception:

Ce traitement des thencapacités permet aux implémentations de promesses d'interopérer, tant qu'elles exposent une thenméthode conforme à Promises / A + . Il permet également aux implémentations Promises / A + d '«assimiler» les implémentations non conformes avec des méthodes raisonnables.

Comment vous devez décider

Vous ne devriez pas - à la place appeler Promise.resolve(x)( Q(x)en Q) qui convertira toujours n'importe quelle valeur ou externe thenen une promesse de confiance. C'est plus sûr et plus facile que d'effectuer ces vérifications vous-même.

vraiment besoin d'être sûr?

Vous pouvez toujours l'exécuter via la suite de tests : D

Vérifier si quelque chose est promis complique inutilement le code, utilisez simplement Promise.resolve

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

})

Voici ma réponse originale, qui a depuis été ratifiée dans la spécification comme moyen de tester une promesse:

Promise.resolve(obj) == obj

Cela fonctionne parce que l' algorithme demande explicitement que Promise.resolvedoit renvoyer l'objet exact transmis si et seulement si c'est une promesse par la définition de la spécification.

J'ai une autre réponse ici, qui disait cela, mais je l'ai changé pour autre chose quand cela ne fonctionnait pas avec Safari à l'époque. C'était il y a un an, et cela fonctionne désormais de manière fiable même dans Safari.

J'aurais modifié ma réponse d'origine, sauf que cela ne me semblait pas correct, étant donné que plus de personnes ont maintenant voté pour la solution modifiée dans cette réponse que l'original. Je pense que c'est la meilleure réponse, et j'espère que vous êtes d'accord.

Mise à jour: ce n'est plus la meilleure réponse. Veuillez voter mon autre réponse à la place.

obj instanceof Promise

devrait le faire. Notez que cela ne peut fonctionner de manière fiable qu'avec les promesses natives d'es6.

Si vous utilisez une cale, une bibliothèque de promesses ou tout autre élément faisant semblant de ressembler à une promesse, il peut être plus approprié de tester un élément "utilisable" (tout ce qui a une .thenméthode), comme indiqué dans d'autres réponses ici.

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

Pour voir si l'objet donné est une promesse ES6 , nous pouvons utiliser ce prédicat:

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

Calling toStringdirectement à partir du Object.prototyperetourne une représentation sous forme de chaîne native du type d'objet donné, ce qui est "[object Promise]"dans notre cas. Cela garantit que l'objet donné

• Contourne les faux positifs tels que ..:
  • Type d'objet auto-défini avec le même nom de constructeur ("Promise").
  • toStringMéthode auto-écrite de l'objet donné.
• Fonctionne dans plusieurs contextes d'environnement (par exemple iframes) contrairement àinstanceof ou isPrototypeOf.

Cependant, tout objet hôte particulier , dont la balise est modifiée viaSymbol.toStringTag , peut retourner "[object Promise]". Cela peut être le résultat souhaité ou non selon le projet (par exemple, s'il existe une implémentation Promise personnalisée).

Pour voir si l'objet provient d'une promesse ES6 native , nous pouvons utiliser:

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 
}

Selon ceci et cette section de la spécification, la représentation sous forme de chaîne de la fonction devrait être:

" identificateur de fonction ( FormalParameterList _opt ) { FunctionBody }"

qui est traité en conséquence ci-dessus. Le FunctionBody est [native code]dans tous les principaux navigateurs.

MDN: Function.prototype.toString

Cela fonctionne également dans plusieurs contextes d'environnement.

Pas une réponse à la question complète, mais je pense qu'il vaut la peine de mentionner que dans Node.js 10, une nouvelle fonction util appelée a isPromiseété ajoutée qui vérifie si un objet est une promesse native ou non:

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

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

Voici comment le package graphql-js détecte les promesses:

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

valueest la valeur retournée de votre fonction. J'utilise ce code dans mon projet et je n'ai aucun problème jusqu'à présent.

Voici la forme de code https://github.com/ssnau/xkit/blob/master/util/is-promise.js

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

si un objet avec une thenméthode, il doit être traité comme un Promise.

Dans le cas où vous utilisez Typescript , je voudrais ajouter que vous pouvez utiliser la fonction "type prédicat". Il suffit d'envelopper la vérification logique dans une fonction qui revient x is Promise<any>et vous n'aurez pas besoin de faire de typecasts. Ci-dessous sur mon exemple, cest soit une promesse ou l'un de mes types que je veux convertir en promesse en appelant la c.fetch()méthode.

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

Plus d'informations: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Si vous utilisez une méthode asynchrone, vous pouvez le faire et éviter toute ambiguïté.

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

Si la fonction renvoie promesse, elle attendra et reviendra avec la valeur résolue. Si la fonction renvoie une valeur, elle sera traitée comme résolue.

Si la fonction ne renvoie pas de promesse aujourd'hui, mais que demain en retourne une ou est déclarée asynchrone, vous serez à l'épreuve du temps.

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

J'utilise cette fonction comme une solution universelle:

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

après avoir cherché un moyen fiable de détecter les fonctions asynchrones ou même les promesses , j'ai fini par utiliser le test suivant:

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

ES6:

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

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