Comment puis-je déterminer de manière synchrone l'état d'une promesse JavaScript?

J'ai une pure promesse JavaScript (implémentation intégrée ou poly-fill):

var promise = new Promise(function (resolve, reject) { /* ... */ });

À partir de la spécification , une promesse peut être l'une des suivantes:

• 'réglé' et 'résolu'
• 'réglé' et 'rejeté'
• 'en attente'

J'ai un cas d'utilisation où je souhaite interroger la promesse de manière synchrone et déterminer:

• la promesse est-elle réglée?

• si oui, la promesse est-elle résolue?

Je sais que je peux utiliser #then()pour planifier le travail à effectuer de manière asynchrone après le changement d'état de la promesse. Je ne demande PAS comment faire cela.

Cette question concerne spécifiquement l' interrogation synchrone de l'état d'une promesse . Comment puis-je atteindre cet objectif?

Aucune API d'inspection synchrone de ce type n'existe pour les promesses JavaScript natives. Il est impossible de faire cela avec des promesses natives. La spécification ne spécifie pas une telle méthode.

Les bibliothèques Userland peuvent le faire, et si vous ciblez un moteur spécifique (comme la v8) et avez accès au code de la plate-forme (c'est-à-dire que vous pouvez écrire du code dans le noyau ), vous pouvez utiliser des outils spécifiques (comme des symboles privés) pour y parvenir. . C'est super spécifique cependant et pas dans le userland.

promise-status-async fait l'affaire. Il est asynchrone mais il ne sert pas thenà attendre que la promesse soit résolue.

const {promiseStatus} = require('promise-status-async');
// ...
if (await promiseStatus(promise) === 'pending') {
    const idle = new Promise(function(resolve) {
        // can do some IDLE job meanwhile
    });
    return idle;
}

Non, pas d'API de synchronisation, mais voici ma version de l'async promiseState(avec l'aide de @Matthijs):

function promiseState(p) {
  const t = {};
  return Promise.race([p, t])
    .then(v => (v === t)? "pending" : "fulfilled", () => "rejected");
}

var a = Promise.resolve();
var b = Promise.reject();
var c = new Promise(() => {});

promiseState(a).then(state => console.log(state)); // fulfilled
promiseState(b).then(state => console.log(state)); // rejected
promiseState(c).then(state => console.log(state)); // pending

Vous pouvez faire une course avec Promise.resolve
Ce n'est pas synchrone mais se produit maintenant

function promiseState(p, isPending, isResolved, isRejected) {
  Promise.race([p, Promise.resolve('a value that p should not return')]).then(function(value) {
    if (value == 'a value that p should not return') {
      (typeof(isPending) === 'function') && isPending();
    }else {
      (typeof(isResolved) === 'function') && isResolved(value);
    }
  }, function(reason) {
    (typeof(isRejected) === 'function') && isRejected(reason);
  });
}

Un petit script pour tester et comprendre leur signification de asynchrone

var startTime = Date.now() - 100000;//padding trick "100001".slice(1) => 00001
function log(msg) {
  console.log((""+(Date.now() - startTime)).slice(1) + ' ' + msg);
  return msg;//for chaining promises
};

function prefix(pref) { return function (value) { log(pref + value); return value; };}

function delay(ms) {
  return function (value) {
    var startTime = Date.now();
    while(Date.now() - startTime < ms) {}
    return value;//for chaining promises
  };
}
setTimeout(log, 0,'timeOut 0 ms');
setTimeout(log, 100,'timeOut 100 ms');
setTimeout(log, 200,'timeOut 200 ms');

var p1 = Promise.resolve('One');
var p2 = new Promise(function(resolve, reject) { setTimeout(resolve, 100, "Two"); });
var p3 = Promise.reject("Three");

p3.catch(delay(200)).then(delay(100)).then(prefix('delayed L3 : '));

promiseState(p1, prefix('p1 Is Pending '), prefix('p1 Is Resolved '), prefix('p1 Is Rejected '));
promiseState(p2, prefix('p2 Is Pending '), prefix('p2 Is Resolved '), prefix('p2 Is Rejected '));
promiseState(p3, prefix('p3 Is Pending '), prefix('p3 Is Resolved '), prefix('p3 Is Rejected '));

p1.then(prefix('Level 1 : ')).then(prefix('Level 2 : ')).then(prefix('Level 3 : '));
p2.then(prefix('Level 1 : ')).then(prefix('Level 2 : ')).then(prefix('Level 3 : '));
p3.catch(prefix('Level 1 : ')).then(prefix('Level 2 : ')).then(prefix('Level 3 : '));
log('end of promises');
delay(100)();
log('end of script');

résultats avec delay (0) (commenter le while in delay)

00001 end of promises
00001 end of script
00001 Level 1 : One
00001 Level 1 : Three
00001 p1 Is Resolved One
00001 p2 Is Pending undefined
00001 p3 Is Rejected Three
00001 Level 2 : One
00001 Level 2 : Three
00001 delayed L3 : Three
00002 Level 3 : One
00002 Level 3 : Three
00006 timeOut 0 ms
00100 timeOut 100 ms
00100 Level 1 : Two
00100 Level 2 : Two
00101 Level 3 : Two
00189 timeOut 200 ms

et les résultats de ce test avec firefox (chrome garde l'ordre)

00000 end of promises
00100 end of script
00300 Level 1 : One
00300 Level 1 : Three
00400 p1 Is Resolved One
00400 p2 Is Pending undefined
00400 p3 Is Rejected Three
00400 Level 2 : One
00400 Level 2 : Three
00400 delayed L3 : Three
00400 Level 3 : One
00400 Level 3 : Three
00406 timeOut 0 ms
00406 timeOut 100 ms
00406 timeOut 200 ms
00406 Level 1 : Two
00407 Level 2 : Two
00407 Level 3 : Two

promiseState crée .race et .then: Niveau 2

Vous pouvez utiliser un hack (laid) dans Node.js jusqu'à ce qu'une méthode native soit proposée:

util = require('util');

var promise1 = new Promise (function (resolve) {
}

var promise2 = new Promise (function (resolve) {

    resolve ('foo');
}

state1 = util.inspect (promise1);
state2 = util.inspect (promise2);

if (state1 === 'Promise { <pending> }') {

    console.log('pending'); // pending
}

if (state2 === "Promise { 'foo' }") {

    console.log ('foo') // foo
}

dans le nœud, disons interne non documenté process.binding('util').getPromiseDetails(promise)

> process.binding('util').getPromiseDetails(Promise.resolve({data: [1,2,3]}));
[ 1, { data: [ 1, 2, 3 ] } ]

> process.binding('util').getPromiseDetails(Promise.reject(new Error('no')));
[ 2, Error: no ]

> process.binding('util').getPromiseDetails(new Promise((resolve) => {}));
[ 0, <1 empty item> ]

Mise à jour: 2019

Bluebird.js propose ceci: http://bluebirdjs.com/docs/api/isfulfilled.html

var Promise = require("bluebird");
let p = Promise.resolve();
console.log(p.isFulfilled());

Si vous préférez créer votre propre wrapper, voici un joli blog à ce sujet.

Parce que JavaScript est monothread, il est difficile de trouver un cas d'utilisation assez courant pour justifier de le placer dans la spécification. Le meilleur endroit pour savoir si une promesse est résolue est dans .then (). Tester si une promesse est remplie créerait une boucle d'interrogation qui est probablement la mauvaise direction.

async / await est une construction intéressante si vous souhaitez raisonner le code async de manière synchrone.

await this();
await that();
return 'success!';

Un autre appel utile est Promise.all ()

var promise1 = Promise.resolve(3);
var promise2 = 42;
var promise3 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3]).then(function(values) {
  console.log(values);
});
// expected output: Array [3, 42, "foo"]

Quand j'ai atteint cette réponse pour la première fois, c'est le cas d'utilisation que je recherchais.

Vous pouvez conclure vos promesses de cette façon

function wrapPromise(promise) {
  var value, error,
      settled = false,
      resolved = false,
      rejected = false,
      p = promise.then(function(v) {
        value = v;
        settled = true;
        resolved = true;
        return v;
      }, function(err) {
        error = err;
        settled = true;
        rejected = true;
        throw err;
      });
      p.isSettled = function() {
        return settled;
      };
      p.isResolved = function() {
        return resolved;
      };
      p.isRejected = function() {
        return rejected;
      };
      p.value = function() {
        return value;
      };
      p.error = function() {
        return error;
      };
      var pThen = p.then, pCatch = p.catch;
      p.then = function(res, rej) {
        return wrapPromise(pThen(res, rej));
      };
      p.catch = function(rej) {
        return wrapPromise(pCatch(rej));
      };
      return p;
}

Il est en effet assez ennuyeux que cette fonctionnalité de base manque. Si vous utilisez node.js, je connais deux solutions de contournement, ni l'une ni l'autre très jolie. Les deux extraits ci-dessous implémentent la même API:

> Promise.getInfo( 42 )                         // not a promise
{ status: 'fulfilled', value: 42 }
> Promise.getInfo( Promise.resolve(42) )        // fulfilled
{ status: 'fulfilled', value: 42 }
> Promise.getInfo( Promise.reject(42) )         // rejected
{ status: 'rejected', value: 42 }
> Promise.getInfo( p = new Promise(() => {}) )  // unresolved
{ status: 'pending' }
> Promise.getInfo( Promise.resolve(p) )         // resolved but pending
{ status: 'pending' }

Il ne semble pas y avoir de moyen de distinguer les deux derniers états de promesse en utilisant l'une ou l'autre astuce.

1. Utilisez l'API de débogage V8

C'est la même astuce qui util.inspectutilise.

const Debug = require('vm').runInDebugContext('Debug');

Promise.getInfo = function( arg ) {
    let mirror = Debug.MakeMirror( arg, true );
    if( ! mirror.isPromise() )
        return { status: 'fulfilled', value: arg };
    let status = mirror.status();
    if( status === 'pending' )
        return { status };
    if( status === 'resolved' )  // fix terminology fuck-up
        status = 'fulfilled';
    let value = mirror.promiseValue().value();
    return { status, value };
};

2. Microtâches exécutées de manière synchrone

Cela évite l'API de débogage, mais présente une sémantique effrayante en provoquant l' process.nextTickexécution synchrone de toutes les microtâches et rappels en attente . Elle a également pour effet secondaire d'empêcher l'erreur de «rejet de promesse non gérée» d'être déclenchée pour la promesse inspectée.

Promise.getInfo = function( arg ) {
    const pending = {};
    let status, value;
    Promise.race([ arg, pending ]).then(
        x => { status = 'fulfilled'; value = x; },
        x => { status = 'rejected'; value = x; }
    );
    process._tickCallback();  // run microtasks right now
    if( value === pending )
        return { status: 'pending' };
    return { status, value };
};

Attention: cette méthode utilise des composants internes Node.js non documentés et peut être modifiée sans avertissement.

Dans Node, vous pouvez déterminer de manière synchrone l'état d'une promesse à l'aide de process.binding('util').getPromiseDetails(/* promise */);.

Cela retournera:

[0, ] pour en attente,

[1, /* value */] pour accompli, ou

[2, /* value */] pour rejeté.

const pending = new Promise(resolve => setTimeout(() => resolve('yakko')));;
const fulfilled = Promise.resolve('wakko');
const rejected = Promise.reject('dot');

[pending, fulfilled, rejected].forEach(promise => {
  console.log(process.binding('util').getPromiseDetails(promise));
});

// pending:   [0, ]
// fulfilled: [1, 'wakko']
// rejected:  [2, 'dot']

Enveloppant ceci dans une fonction d'assistance:

const getStatus = promise => ['pending', 'fulfilled', 'rejected'][
  process.binding('util').getPromiseDetails(promise)[0]
];

getStatus(pending); // pending
getStatus(fulfilled); // fulfilled
getStatus(rejected); // rejected

ce que vous pouvez faire, c'est utiliser une variable pour stocker l'état, définir manuellement l'état sur cette variable et vérifier cette variable.

var state = 'pending';

new Promise(function(ff, rjc) {
  //do something async

  if () {//if success
    state = 'resolved';

    ff();//
  } else {
    state = 'rejected';

    rjc();
  }
});

console.log(state);//check the state somewhere else in the code

bien sûr, cela signifie que vous devez avoir accès au code original de la promesse. Sinon, vous pouvez faire:

var state = 'pending';

//you can't access somePromise's code
somePromise.then(function(){
  state = 'resolved';
}, function() {
  state = 'rejected';
})

console.log(state);//check the promise's state somewhere else in the code

Ma solution est plus de codage, mais je pense que vous n'auriez probablement pas à le faire pour chaque promesse que vous utilisez.

À partir de la version 8 de Node.js, vous pouvez désormais utiliser le package sage-inspection pour inspecter de manière synchrone les promesses natives (sans aucun piratage dangereux).

Vous pouvez ajouter une méthode à Promise.prototype. Cela ressemble à ceci:

Modifié: La première solution ne fonctionne pas correctement, comme la plupart des réponses ici. Il renvoie «en attente» jusqu'à ce que la fonction asynchrone «.then» soit appelée, ce qui ne se produit pas immédiatement. (Il en va de même pour les solutions utilisant Promise.race). Ma deuxième solution résout ce problème.

if (window.Promise) {
    Promise.prototype.getState = function () {
        if (!this.state) {
            this.state = "pending";
            var that = this;
            this.then(
                function (v) {
                    that.state = "resolved";
                    return v;
                },
                function (e) {
                    that.state = "rejected";
                    return e;
                });
        }
        return this.state;
    };
}

Vous pouvez l'utiliser sur n'importe quelle promesse. Par exemple:

myPromise = new Promise(myFunction);
console.log(myPromise.getState()); // pending|resolved|rejected

Deuxième solution (et correcte):

if (window.Promise) {
    Promise.stateable = function (func) {
        var state = "pending";
        var pending = true;
        var newPromise = new Promise(wrapper);
        newPromise.state = state;
        return newPromise;
        function wrapper(resolve, reject) {
            func(res, rej);
            function res(e) {
                resolve(e);
                if (pending) {
                    if (newPromise)
                        newPromise.state = "resolved";
                    else
                        state = "resolved";
                    pending = false;
                }
            }
            function rej(e) {
                reject(e);
                if (pending) {
                    if (newPromise)
                        newPromise.state = "rejected";
                    else
                        state = "rejected";
                    pending = false;
                }
            }
        }
    };
}

Et utilisez-le:

Remarque : Dans cette solution, vous n'avez pas besoin d'utiliser l'opérateur "new".

myPromise = Promise.stateable(myFunction);
console.log(myPromise.state); // pending|resolved|rejected

Voici une version es6 plus étoffée de QueryablePromise, permettant la possibilité de chaîner ensuite et d'attraper après la première résolution et de résoudre ou de rejeter immédiatement pour garder l'API cohérente avec la promesse native.

const PROMISE = Symbol('PROMISE')
const tap = fn => x => (fn(x), x)
const trace = label => tap(x => console.log(label, x))

class QueryablePromise {
  resolved = false
  rejected = false
  fulfilled = false
  catchFns = []
  constructor(fn) {
    this[PROMISE] = new Promise(fn)
      .then(tap(() => {
        this.fulfilled = true
        this.resolved = true
      }))
      .catch(x => {
        this.fulfilled = true
        this.rejected = true
        return Promise.reject(x)
      })
  }
  then(fn) {
    this[PROMISE].then(fn)
    return this
  }
  catch(fn) {
    this[PROMISE].catch(fn)
    return this
  }
  static resolve(x) {
    return new QueryablePromise((res) => res(x))
  }
  static reject(x) {
    return new QueryablePromise((_, rej) => rej(x))
  }
}

const resolvedPromise = new QueryablePromise((res) => {
  setTimeout(res, 200, 'resolvedPromise')
})

const rejectedPromise = new QueryablePromise((_, rej) => {
  setTimeout(rej, 200, 'rejectedPromise')
})

// ensure our promises have not been fulfilled
console.log('test 1 before: is resolved', resolvedPromise.resolved)
console.log('test 2 before: is rejected', rejectedPromise.rejected)


setTimeout(() => {
  // check to see the resolved status of our promise
  console.log('test 1 after: is resolved', resolvedPromise.resolved)
  console.log('test 2 after: is rejected', rejectedPromise.rejected)
}, 300)

// make sure we can immediately resolve a QueryablePromise
const immediatelyResolvedPromise = QueryablePromise.resolve('immediatelyResolvedPromise')
  // ensure we can chain then
  .then(trace('test 3 resolved'))
  .then(trace('test 3 resolved 2'))
  .catch(trace('test 3 rejected'))

// make sure we can immediately reject a QueryablePromise
const immediatelyRejectedPromise = QueryablePromise.reject('immediatelyRejectedPromise')
  .then(trace('test 4 resolved'))
  .catch(trace('test 4 rejected'))

<script src="https://codepen.io/synthet1c/pen/KyQQmL.js"></script>

awaitutilisation à la réponse de @ jib , avec prototypage idiomatique.

Object.defineProperty(Promise.prototype, "state", {
    get: function(){
        const o = {};
        return Promise.race([this, o]).then(
            v => v === o ? "pending" : "resolved",
            () => "rejected");
    }
});

// usage: console.log(await <Your Promise>.state);
(async () => {
    console.log(await Promise.resolve(2).state);  // "resolved"
    console.log(await Promise.reject(0).state);   // "rejected"
    console.log(await new Promise(()=>{}).state); // "pending"
})();

notez que cette fonction asynchrone exécute "presque" immédiatement comme une fonction synchronisée (ou peut-être même instantanément).

2019:

Le moyen le plus simple de le faire, comme je le sais, est thenableune enveloppe super fine autour de la promesse ou de tout travail asynchrone.

const sleep = (t) => new Promise(res => setTimeout(res,t));
const sleeping = sleep(30);

function track(promise){
    let state = 'pending';
    promise = promise.finally( _=> state ='fulfilled');
    return {
        get state(){return state},
        then: promise.then.bind(promise), /*thentable*/
        finally:promise.finally.bind(promise),
        catch:promise.catch.bind(promise),
    }
}


promise = track(sleeping);
console.log(promise.state) // pending

promise.then(function(){
    console.log(promise.state); // fulfilled
})

Vous pouvez extendla classe Promise pour créer une nouvelle classe Promise interrogeable .

Vous pouvez créer votre propre sous-classe, par exemple QueryablePromise, en héritant de la Promiseclasse disponible nativement , dont les instances auraient une statuspropriété disponible que vous pouvez utiliser pour interroger l'état des objets de promesse de manière synchrone . Une implémentation de celui-ci peut être vue ci-dessous ou se référer à ceci pour une meilleure explication.

class QueryablePromise extends Promise {
  constructor (executor) {
    super((resolve, reject) => executor(
      data => {
        resolve(data)
        this._status = 'Resolved'
      },
      err => {
        reject(err)
        this._status = 'Rejected'
      },
    ))
    this._status = 'Pending'
  }

  get status () {
    return this._status
  }
}
 
// Create a promise that resolves after 5 sec 
var myQueryablePromise = new QueryablePromise((resolve, reject) => {
  setTimeout(() => resolve(), 5000)
})

// Log the status of the above promise every 500ms
setInterval(() => {
  console.log(myQueryablePromise.status)
}, 500)

Il y a une autre élégante façon et hacky de vérifier si une promesse est toujours en attente juste en convertissant l'objet entier à la chaîne et vérifiez avec l'aide de l' inspection comme ceci: util.inspect(myPromise).includes("pending").

Testé sur Node.js 8,9,10,11,12,13

Voici un exemple complet

const util = require("util")

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

(async ()=>{
  let letmesleep = sleep(3000)
  setInterval(()=>{
    console.log(util.inspect(letmesleep).includes("pending"))
  },1000)
})()

Résultat:

true
true
false
false
false

Si vous utilisez ES7 expérimental, vous pouvez utiliser async pour encapsuler facilement la promesse que vous souhaitez écouter.

async function getClient() {
  let client, resolved = false;
  try {
    client = await new Promise((resolve, reject) => {
      let client = new Client();

      let timer = setTimeout(() => {
         reject(new Error(`timeout`, 1000));
         client.close();
      });

      client.on('ready', () => {
        if(!resolved) {
          clearTimeout(timer);
          resolve(client);
        }
      });

      client.on('error', (error) => {
        if(!resolved) {
          clearTimeout(timer);
          reject(error);
        }
      });

      client.on('close', (hadError) => {
        if(!resolved && !hadError) {
          clearTimeout(timer);
          reject(new Error("close"));
        }
      });
    });

    resolved = true;
  } catch(error) {
    resolved = true;
    throw error;
  }
  return client;
}

J'ai écrit un petit package npm, promise-value, qui fournit un wrapper de promesse avec un resolvedindicateur:

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

Il donne également un accès synchrone à la valeur de promesse (ou erreur). Cela ne modifie pas l'objet Promise lui-même, en suivant le modèle d'habillage plutôt que d'étendre.

C'est une question plus ancienne mais j'essayais de faire quelque chose de similaire. J'ai besoin de garder n travailleurs. Ils sont structurés dans une promesse. Je dois scanner et voir s'ils sont résolus, rejetés ou toujours en attente. Si résolu, j'ai besoin de la valeur, si rejeté, faites quelque chose pour corriger le problème ou en attente. En cas de résolution ou de rejet, je dois commencer une autre tâche pour continuer. Je ne peux pas trouver un moyen de le faire avec Promise.all ou Promise.race car je continue à travailler les promesses dans un tableau et ne trouve aucun moyen de les supprimer. Alors je crée un ouvrier qui fait l'affaire

J'ai besoin d'une fonction de générateur de promesse qui renvoie une promesse qui résout ou rejette si nécessaire. Il est appelé par une fonction qui met en place le cadre pour savoir ce que fait la promesse.

Dans le code ci-dessous, le générateur renvoie simplement une promesse basée sur setTimeout.

C'est ici

//argObj should be of form
// {succeed: <true or false, nTimer: <desired time out>}
function promiseGenerator(argsObj) {
  let succeed = argsObj.succeed;          
  let nTimer = argsObj.nTimer;
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (succeed) {
        resolve('ok');
      }
      else {
        reject(`fail`);
      }
    }, nTimer);
  })

}

function doWork(generatorargs) {
  let sp = { state: `pending`, value: ``, promise: "" };
  let p1 = promiseGenerator(generatorargs)
    .then((value) => {
      sp.state = "resolved";
      sp.value = value;
    })
    .catch((err) => {
      sp.state = "rejected";
      sp.value = err;
    })
  sp.promise = p1;
  return sp;
}

doWork renvoie un objet contenant la promesse, son état et sa valeur retournée.

Le code suivant exécute une boucle qui teste l'état et crée de nouveaux nœuds de calcul pour le maintenir à 3 nœuds de calcul en cours d'exécution.

let promiseArray = [];

promiseArray.push(doWork({ succeed: true, nTimer: 1000 }));
promiseArray.push(doWork({ succeed: true, nTimer: 500 }));
promiseArray.push(doWork({ succeed: false, nTimer: 3000 }));

function loopTimerPromise(delay) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve('ok');
    }, delay)
  })
}

async function looper() {
  let nPromises = 3;      //just for breaking loop
  let nloop = 0;          //just for breaking loop
  let i;
  //let continueLoop = true;
  while (true) {
    await loopTimerPromise(900);  //execute loop every 900ms
    nloop++;
    //console.log(`promiseArray.length = ${promiseArray.length}`);
    for (i = promiseArray.length; i--; i > -1) {
      console.log(`index ${i} state: ${promiseArray[i].state}`);
      switch (promiseArray[i].state) {
        case "pending":
          break;
        case "resolved":
          nPromises++;
          promiseArray.splice(i, 1);
          promiseArray.push(doWork({ succeed: true, nTimer: 1000 }));
          break;
        case "rejected":
          //take recovery action
          nPromises++;
          promiseArray.splice(i, 1);
          promiseArray.push(doWork({ succeed: false, nTimer: 500 }));
          break;
        default:
          console.log(`error bad state in i=${i} state:${promiseArray[i].state} `)
          break;
      }
    }
    console.log(``);
    if (nloop > 10 || nPromises > 10) {
      //should do a Promise.all on remaining promises to clean them up but not for test
      break;
    }
  }
}

looper();

Testé dans node.js

BTW Pas tellement dans cette réponse, mais dans d'autres sur des sujets similaires, je déteste quand quelqu'un dit «vous ne comprenez pas» ou «ce n'est pas comme ça que ça marche». Je suppose généralement que le questionneur sait ce qu'il veut. Suggérer une meilleure façon, c'est super. Une explication patiente du fonctionnement des promesses serait également une bonne chose.

J'ai trouvé que cette solution était simple et me permettait de continuer à utiliser les promesses natives tout en ajoutant des vérifications synchrones utiles. Je n'avais pas non plus besoin de récupérer une bibliothèque de promesses complète.

CAVEAT: Cela ne fonctionne que s'il y a une sorte de rupture dans le thread d'exécution actuel pour permettre aux promesses de s'exécuter AVANT de vérifier les constructions synchrones. Cela rend cela d'une utilité plus limitée que je ne le pensais initialement - toujours utile pour mon cas d'utilisation (merci à Benjamin Gruenbaum pour l'avoir signalé)

/**
 * This function allow you to modify a JS Promise by adding some status properties.
 * Based on: http://stackoverflow.com/questions/21485545/is-there-a-way-to-tell-if-an-es6-promise-is-fulfilled-rejected-resolved
 * But modified according to the specs of promises : https://promisesaplus.com/
 */
function MakeQuerablePromise(promise) {
    // Don't modify any promise that has been already modified.
    if (promise.isFulfilled) return promise;

    // Set initial state
    var isPending = true;
    var isRejected = false;
    var isFulfilled = false;

    // Observe the promise, saving the fulfillment in a closure scope.
    var result = promise.then(
        function(v) {
            isFulfilled = true;
            isPending = false;
            return v; 
        }, 
        function(e) {
            isRejected = true;
            isPending = false;
            throw e; 
        }
    );

    result.isFulfilled = function() { return isFulfilled; };
    result.isPending = function() { return isPending; };
    result.isRejected = function() { return isRejected; };
    return result;
}

wrappedPromise = MakeQueryablePromise(Promise.resolve(3)); 
setTimeout(function() {console.log(wrappedPromise.isFulfilled())}, 1);

De https://ourcodeworld.com/articles/read/317/how-to-check-if-a-javascript-promise-has-been-fulfilled-rejected-or-resolved qui a basé leur réponse sur Y a-t-il un moyen de dire si une promesse ES6 est remplie / rejetée / résolue?