Bagaimana saya bisa secara sinkron menentukan status JavaScript Promise?

Saya memiliki Janji JavaScript murni (implementasi bawaan atau poli-isi):

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

Dari spesifikasinya , Janji dapat menjadi salah satu dari:

• 'diselesaikan' dan 'diselesaikan'
• 'diselesaikan' dan 'ditolak'
• 'tertunda'

Saya memiliki kasus penggunaan di mana saya ingin menginterogasi Janji secara serempak dan menentukan:

• Apakah Janji sudah terpenuhi?

• jika demikian, apakah Janji itu terselesaikan?

Saya tahu bahwa saya dapat menggunakan #then()untuk menjadwalkan pekerjaan yang akan dilakukan secara tidak sinkron setelah kondisi perubahan Janji. Saya TIDAK bertanya bagaimana melakukan ini.

Pertanyaan ini secara khusus tentang interogasi sinkron dari negara Janji . Bagaimana saya bisa mencapai ini?

Tidak ada API inspeksi sinkron seperti itu untuk janji JavaScript asli. Tidak mungkin melakukan ini dengan janji-janji asli. Spesifikasi tidak menentukan metode seperti itu.

Perpustakaan Userland dapat melakukan ini, dan jika Anda menargetkan mesin tertentu (seperti v8) dan memiliki akses ke kode platform (yaitu, Anda dapat menulis kode dalam inti ) maka Anda dapat menggunakan alat khusus (seperti simbol pribadi) untuk mencapai ini . Itu super spesifik dan bukan di userland.

janji-status-async berhasil . Itu async tetapi tidak digunakan thenuntuk menunggu janji untuk diselesaikan.

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

Tidak, tidak ada API sinkronisasi, tapi ini versi async saya promiseState(dengan bantuan dari @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

Anda dapat membuat balapan dengan Promise.resolve
Ini tidak sinkron tetapi terjadi sekarang

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

Sebuah skrip kecil untuk menguji dan memahami maknanya secara asinkron

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

hasil dengan penundaan (0) (beri komentar pada saat penundaan)

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

dan hasil tes ini dengan firefox (chrome keep the order)

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

janjiState membuat .race dan .then: Level 2

Anda dapat menggunakan peretasan (jelek) di Node.js hingga metode asli ditawarkan:

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
}

dalam simpul, katakanlah internal tidak berdokumen 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> ]

Diperbarui: 2019

Bluebird.js menawarkan ini: http://bluebirdjs.com/docs/api/isfulfilled.html

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

Jika Anda lebih suka membuat bungkus Anda sendiri, berikut adalah blog yang bagus .

Karena JavaScript adalah single-threaded, sulit untuk menemukan kasus penggunaan yang cukup umum untuk membenarkan memasukkan ini ke dalam spesifikasi. Tempat terbaik untuk mengetahui apakah janji terselesaikan ada di .then (). Menguji apakah Janji telah dipenuhi akan membuat sebuah polling loop yang kemungkinan besar adalah arah yang salah.

async / await adalah konstruk yang bagus jika Anda ingin memberikan kode async secara sinkron.

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

Panggilan berguna lainnya adalah 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"]

Ketika saya pertama kali meraih jawaban ini, itulah use case yang saya cari.

Anda dapat memenuhi janji Anda dengan cara ini

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

Memang sangat menjengkelkan bahwa fungsi dasar ini tidak ada. Jika Anda menggunakan node.js maka saya tahu dua solusi, tak satu pun dari mereka sangat cantik. Kedua cuplikan di bawah ini menerapkan API yang sama:

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

Sepertinya tidak ada cara untuk membedakan kedua negara janji terakhir menggunakan salah satu trik.

1. Gunakan API debug V8

Ini adalah trik yang sama yang util.inspectdigunakan.

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. Jalankan microtasks secara sinkron

Ini menghindari API debug, tetapi memiliki semantik yang menakutkan dengan menyebabkan semua mikrotasks dan process.nextTickcallback yang tertunda dijalankan secara serempak. Ini juga memiliki efek samping mencegah kesalahan "penolakan janji yang tidak tertangani" pernah dipicu untuk janji yang diinspeksi.

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

Peringatan: Metode ini menggunakan internal Node.js yang tidak berdokumen dan dapat diubah tanpa peringatan.

Di Node, Anda dapat secara sinkron menentukan status janji menggunakan process.binding('util').getPromiseDetails(/* promise */);.

Ini akan mengembalikan:

[0, ] untuk menunggu,

[1, /* value */] untuk dipenuhi, atau

[2, /* value */] untuk ditolak.

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']

Membungkus ini ke dalam fungsi pembantu:

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

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

apa yang dapat Anda lakukan, adalah menggunakan variabel untuk menyimpan keadaan, secara manual mengatur keadaan ke variabel itu, dan memeriksa variabel itu.

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

tentu saja, ini berarti Anda harus memiliki akses ke kode janji yang asli. Jika tidak, maka Anda dapat melakukan:

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

Solusi saya lebih banyak coding, tapi saya pikir Anda mungkin tidak perlu melakukan ini untuk setiap janji yang Anda gunakan.

Pada Node.js versi 8, Anda sekarang dapat menggunakan paket inspeksi bijak untuk secara sinkron memeriksa janji-janji asli (tanpa peretasan berbahaya).

Anda dapat menambahkan metode ke Promise.prototype. Ini terlihat seperti ini:

Diedit: Solusi pertama tidak berfungsi sebagaimana mestinya, seperti sebagian besar jawaban di sini. Ini mengembalikan "pending" sampai fungsi asinkron ".then" dipanggil, yang tidak terjadi segera. (Hal yang sama adalah tentang solusi menggunakan Promise.race). Solusi kedua saya memecahkan masalah ini.

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

Anda dapat menggunakannya di Janji apa pun. Sebagai contoh:

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

Solusi kedua (dan benar):

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

Dan gunakan itu:

Perhatikan : Dalam solusi ini Anda tidak harus menggunakan operator "baru".

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

Ini adalah versi QueryablePromise yang lebih sempurna, memungkinkan kemampuan untuk rantai kemudian dan menangkap setelah tekad pertama dan segera menyelesaikan atau menolak untuk menjaga api tetap konsisten dengan Janji asli.

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>

awaitpenggunaan untuk jawaban @ jib , dengan prototyping idiomatik.

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

perhatikan bahwa fungsi async ini menjalankan "hampir" segera seperti fungsi yang disinkronkan (atau sebenarnya mungkin secara instan).

2019:

Cara sederhana untuk melakukan itu seperti yang saya tahu adalah thenable, pembungkus super tipis di sekitar janji atau pekerjaan async.

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

Anda dapat extendkelas Promise untuk membuat kelas Promise yang dapat ditanyakan baru .

Anda dapat membuat subclass Anda sendiri, katakanlah QueryablePromise, dengan mewarisi dari Promisekelas yang tersedia secara asli , instance yang akan memiliki statusproperti yang tersedia di dalamnya yang dapat Anda gunakan untuk menanyakan status objek janji secara serempak . Implementasinya dapat dilihat di bawah atau merujuk ini untuk penjelasan yang lebih baik.

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)

Ada lagi yang elegan cara & Hacky memeriksa apakah janji masih tertunda hanya dengan mengubah seluruh objek string dan memeriksa dengan bantuan memeriksa seperti ini: util.inspect(myPromise).includes("pending").

Diuji pada Node.js 8,9,10,11,12,13

Ini contoh lengkapnya

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

Hasil:

true
true
false
false
false

Jika Anda menggunakan ES7 eksperimental, Anda dapat menggunakan async untuk dengan mudah membungkus janji yang ingin Anda dengarkan.

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

Saya telah menulis paket npm kecil, nilai janji, yang menyediakan pembungkus janji dengan resolvedbendera:

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

Ini juga memberikan akses sinkron ke nilai janji (atau kesalahan). Ini tidak mengubah objek Janji itu sendiri, mengikuti bungkus daripada memperpanjang pola.

Ini adalah pertanyaan lama tetapi saya mencoba melakukan hal serupa. Saya perlu menjaga agar pekerja tetap berjalan. Mereka terstruktur dalam sebuah janji. Saya perlu memindai dan melihat apakah mereka diselesaikan, ditolak atau masih tertunda. Jika diselesaikan, saya perlu nilainya, jika ditolak melakukan sesuatu untuk memperbaiki masalah atau menunggu keputusan. Jika diselesaikan atau ditolak, saya harus memulai tugas lain untuk terus berjalan. Saya tidak dapat menemukan cara untuk melakukannya dengan Promise.all atau Promise.race karena saya terus bekerja janji dalam array dan tidak dapat menemukan cara untuk menghapusnya. Jadi saya membuat pekerja yang melakukan trik

Saya membutuhkan fungsi generator janji yang mengembalikan janji yang menyelesaikan atau menolak seperlunya. Ini disebut oleh fungsi yang mengatur kerangka kerja untuk mengetahui apa yang dilakukan janji.

Dalam kode di bawah ini generator hanya mengembalikan janji berdasarkan setTimeout.

Ini dia

//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 mengembalikan objek yang berisi janji dan statusnya serta nilai yang dikembalikan.

Kode berikut menjalankan loop yang menguji negara dan membuat pekerja baru agar tetap di 3 pekerja berjalan.

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

Diuji dalam node.js

BTW Bukan dalam jawaban ini tetapi pada topik lain yang serupa, saya BENCI ketika seseorang mengatakan "Anda tidak mengerti" atau "itu bukan cara kerjanya" Saya biasanya menganggap penanya tahu apa yang mereka inginkan. Menyarankan cara yang lebih baik itu bagus. Penjelasan yang sabar tentang bagaimana janji bekerja juga akan baik.

Saya menemukan solusi ini sederhana dan memungkinkan saya untuk terus menggunakan janji-janji asli tetapi menambahkan pemeriksaan sinkron yang berguna. Saya juga tidak perlu menarik seluruh perpustakaan janji.

CAVEAT: Ini hanya berfungsi jika ada semacam jeda di utas eksekusi saat ini untuk memungkinkan janji untuk dieksekusi SEBELUM memeriksa konstruksi sinkron. Itu membuat kegunaan ini lebih terbatas daripada yang saya pikirkan - masih berguna untuk kasus penggunaan saya (Terima kasih Benjamin Gruenbaum untuk menunjukkan ini)

/**
 * 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);

Dari https://ourcodeworld.com/articles/read/317/how-to-check-if-a-javascript-promise-has-been-fulfilled-rejected-or-resolved yang mendasarkan jawaban mereka pada apakah ada cara untuk memberi tahu apakah janji ES6 dipenuhi / ditolak / diselesaikan?