Làm cách nào tôi có thể xác định đồng bộ trạng thái của Promise JavaScript?

Tôi có một Promise JavaScript thuần túy (triển khai tích hợp hoặc đa điền):

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

Từ đặc điểm kỹ thuật , một Promise có thể là một trong:

• 'giải quyết' và 'giải quyết'
• 'giải quyết' và 'từ chối'
• 'đang chờ xử lý'

Tôi có một trường hợp sử dụng mà tôi muốn thẩm vấn Promise một cách đồng bộ và xác định:

• Lời hứa đã được giải quyết chưa?

• Nếu vậy, Lời hứa có được giải quyết không?

Tôi biết rằng tôi có thể sử dụng #then()để lên lịch làm việc để được thực hiện không đồng bộ sau trạng thái thay đổi Promise. Tôi KHÔNG hỏi làm thế nào để làm điều này.

Câu hỏi này đặc biệt về thẩm vấn đồng bộ trạng thái của Promise . Làm thế nào tôi có thể đạt được điều này?

Không có API kiểm tra đồng bộ như vậy tồn tại cho các lời hứa JavaScript gốc. Không thể làm điều này với những lời hứa bản địa. Các đặc điểm kỹ thuật không chỉ định một phương pháp như vậy.

Thư viện Userland có thể làm điều này và nếu bạn đang nhắm mục tiêu một công cụ cụ thể (như v8) và có quyền truy cập vào mã nền tảng (nghĩa là bạn có thể viết mã trong lõi ) thì bạn có thể sử dụng các công cụ cụ thể (như ký hiệu riêng) để đạt được điều này . Đó là siêu cụ thể mặc dù và không phải trong người dùng.

lời hứa-trạng thái không đồng bộ thực hiện các mẹo. Đó là async nhưng nó không sử dụng thenđể chờ lời hứa được giải quyết.

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

Không, không có API đồng bộ hóa, nhưng đây là phiên bản async của tôi promiseState(với sự trợ giúp từ @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

Bạn có thể thực hiện một cuộc đua với Promise.resolve
Nó không đồng bộ nhưng xảy ra ngay bây giờ

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

Một tập lệnh nhỏ để kiểm tra và hiểu ý nghĩa của chúng không đồng bộ

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

kết quả với độ trễ (0) (nhận xét trong khi trì hoãn)

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

và kết quả của thử nghiệm này với firefox (chrome giữ trật tự)

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 thực hiện .race và .then: Cấp 2

Bạn có thể sử dụng hack (xấu xí) trong Node.js cho đến khi phương thức gốc được cung cấp:

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
}

trong nút, nói nội bộ không có giấy tờ 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> ]

Cập nhật: 2019

Bluebird.js cung cấp điều này: http://bluebirdjs.com/docs/api/isfulfills.html

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

Nếu bạn muốn tạo trình bao bọc của riêng mình, đây là một blog hay về nó.

Vì JavaScript là một luồng đơn, nên thật khó để tìm thấy một trường hợp sử dụng đủ phổ biến để biện minh cho việc đưa cái này vào thông số kỹ thuật. Nơi tốt nhất để biết nếu một lời hứa được giải quyết là trong .then (). Việc kiểm tra nếu một Promise được điền đầy đủ sẽ tạo ra một vòng bỏ phiếu rất có thể là hướng sai.

async / await là một cấu trúc đẹp nếu bạn muốn lý giải mã async một cách đồng bộ.

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

Một cuộc gọi hữu ích khác là 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"]

Khi tôi lần đầu tiên đạt được câu trả lời này, đó là trường hợp sử dụng mà tôi đang tìm kiếm.

Bạn có thể thực hiện lời hứa của mình theo cách này

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

Thật sự khá khó chịu khi chức năng cơ bản này bị thiếu. Nếu bạn đang sử dụng node.js thì tôi biết hai cách giải quyết, cả hai đều không đẹp. Cả hai đoạn dưới đây đều thực hiện cùng một 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' }

Dường như không có cách nào để phân biệt hai trạng thái hứa hẹn cuối cùng bằng cách sử dụng một trong hai mẹo.

1. Sử dụng API gỡ lỗi V8

Đây là thủ thuật tương tự mà util.inspectsử dụng.

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. Chạy đồng bộ microt Nhiệm vụ

Điều này tránh API gỡ lỗi, nhưng có một số ngữ nghĩa đáng sợ bằng cách khiến tất cả các microt Nhiệm vụ và process.nextTickcuộc gọi lại đang chờ được chạy đồng bộ. Nó cũng có tác dụng phụ trong việc ngăn chặn lỗi "từ chối lời hứa chưa được xử lý" không bao giờ được kích hoạt cho lời hứa đã được kiểm tra.

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

Hãy cẩn thận: Phương pháp này sử dụng nội bộ Node.js không có giấy tờ và có thể được thay đổi mà không cần cảnh báo.

Trong Node, bạn có thể xác định đồng bộ trạng thái của lời hứa bằng cách sử dụng process.binding('util').getPromiseDetails(/* promise */);.

Điều này sẽ trở lại:

[0, ] để chờ xử lý,

[1, /* value */] để hoàn thành, hoặc

[2, /* value */] cho bị từ chối.

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

Gói cái này vào một hàm trợ giúp:

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

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

những gì bạn có thể làm là sử dụng một biến để lưu trữ trạng thái, tự đặt trạng thái cho biến đó và kiểm tra biến đó.

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

Tất nhiên, điều này có nghĩa là bạn phải có quyền truy cập vào mã gốc của lời hứa. Nếu bạn không, thì bạn có thể làm:

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

Giải pháp của tôi là mã hóa nhiều hơn, nhưng tôi nghĩ có lẽ bạn sẽ không phải làm điều này cho mỗi lời hứa bạn sử dụng.

Kể từ phiên bản 8 của Node.js, giờ đây bạn có thể sử dụng gói kiểm tra khôn ngoan để kiểm tra đồng bộ các lời hứa riêng (không có bất kỳ hack nào nguy hiểm).

Bạn có thể thêm một phương thức vào Promise.prototype. Nó trông như thế này:

Đã chỉnh sửa: Giải pháp đầu tiên không hoạt động đúng, giống như hầu hết các câu trả lời ở đây. Nó trả về "đang chờ xử lý" cho đến khi hàm không đồng bộ ".then" được gọi, điều này không xảy ra ngay lập tức. (Tương tự là về các giải pháp sử dụng Promise.race). Giải pháp thứ hai của tôi giải quyết vấn đề này.

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

Bạn có thể sử dụng nó trên bất kỳ Promise. Ví dụ như:

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

Giải pháp thứ hai (và chính xác):

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

Và sử dụng nó:

Lưu ý : Trong giải pháp này, bạn không phải sử dụng toán tử "mới".

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

Đây là phiên bản es6 mạnh mẽ hơn của QueryablePromise, cho phép khả năng xâu chuỗi và bắt sau khi giải quyết lần đầu và giải quyết ngay lập tức hoặc từ chối để giữ api phù hợp với Promise gốc.

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>

awaitsử dụng cho câu trả lời của @ jib , với nguyên mẫu thành ngữ.

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

lưu ý rằng chức năng async này thực thi "gần như" ngay lập tức như chức năng được đồng bộ hóa (hoặc thực sự có thể là ngay lập tức).

2019:

Cách đơn giản để làm điều đó như tôi biết là thenable, trình bao bọc siêu mỏng xung quanh lời hứa hoặc bất kỳ công việc không đồng bộ nào.

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

Bạn có thể extendlớp Promise để tạo ra một mới queryable Promise lớp.

Bạn có thể tạo lớp con của riêng mình QueryablePromise, bằng cách kế thừa từ Promiselớp có sẵn , các trường hợp sẽ có một thuộc statustính có sẵn trên đó mà bạn có thể sử dụng để truy vấn trạng thái của các đối tượng lời hứa một cách đồng bộ . Một triển khai của nó có thể được nhìn thấy dưới đây hoặc tham khảo điều này để giải thích tốt hơn.

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)

Có một cách kiểm tra thanh lịch & hacky khác nếu một lời hứa vẫn đang chờ xử lý chỉ bằng cách chuyển đổi toàn bộ đối tượng thành chuỗi và kiểm tra nó với sự trợ giúp của kiểm tra như sau : util.inspect(myPromise).includes("pending").

Đã thử nghiệm trên Node.js 8,9,10,11,12,13

Đây là một ví dụ đầy đủ

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

Kết quả:

true
true
false
false
false

Nếu bạn đang sử dụng thử nghiệm ES7, bạn có thể sử dụng async để dễ dàng thực hiện lời hứa bạn muốn nghe.

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

Tôi đã viết một gói npm nhỏ, giá trị lời hứa, cung cấp một trình bao bọc lời hứa với một resolvedcờ:

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

Nó cũng cho phép truy cập đồng bộ vào giá trị lời hứa (hoặc lỗi). Điều này không làm thay đổi chính đối tượng Promise, theo mẫu bao bọc hơn là mở rộng mẫu.

Đây là câu hỏi cũ hơn nhưng tôi đã cố gắng làm một cái gì đó tương tự. Tôi cần phải giữ n công nhân đi. Chúng được cấu trúc trong một lời hứa. Tôi cần quét và xem nếu chúng được giải quyết, từ chối hoặc vẫn đang chờ xử lý. Nếu được giải quyết, tôi cần giá trị, nếu bị từ chối, hãy làm gì đó để sửa lỗi hoặc chờ xử lý. Nếu giải quyết hoặc từ chối tôi cần bắt đầu một nhiệm vụ khác để tiếp tục n. Tôi không thể tìm ra cách để làm điều đó với Promise.all hoặc Promise.race khi tôi tiếp tục thực hiện các lời hứa trong một mảng và không thể tìm cách xóa chúng. Vì vậy, tôi tạo ra một công nhân thực hiện các mẹo

Tôi cần một hàm tạo lời hứa trả về một lời hứa giải quyết hoặc từ chối khi cần thiết. Nó được gọi bởi một chức năng thiết lập khung để biết lời hứa đang làm gì.

Trong mã bên dưới, trình tạo chỉ cần trả về một lời hứa dựa trên setTimeout.

Nó đây rồi

//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 trả về một đối tượng chứa lời hứa và trạng thái của nó và giá trị được trả về.

Đoạn mã sau chạy một vòng lặp kiểm tra trạng thái và tạo ra các công nhân mới để giữ nó ở 3 công nhân đang chạy.

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

Đã thử nghiệm trong node.js

BTW Không phải trong câu trả lời này quá nhiều nhưng ở những người khác về các chủ đề tương tự, tôi ghét nó khi ai đó nói "bạn không hiểu" hoặc "đó không phải là cách nó hoạt động" Tôi thường cho rằng người hỏi biết họ muốn gì. Đề xuất một cách tốt hơn là tuyệt vời. Một lời giải thích kiên nhẫn về cách hứa hẹn làm việc cũng sẽ tốt.

Tôi thấy giải pháp này đơn giản và cho phép tôi tiếp tục sử dụng các lời hứa riêng nhưng thêm các kiểm tra đồng bộ hữu ích. Tôi cũng không phải kéo vào toàn bộ thư viện lời hứa.

CAVEAT: Điều này chỉ hoạt động nếu có một số loại ngắt trong luồng thực thi hiện tại để cho phép các lời hứa thực thi TRƯỚC KHI kiểm tra các cấu trúc đồng bộ. Điều đó làm cho tính hữu dụng này hạn chế hơn so với tôi nghĩ ban đầu - vẫn hữu ích cho trường hợp sử dụng của tôi (Cảm ơn Benjamin Gruenbaum vì đã chỉ ra điều này)

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

Từ https://ourcodeworld.com/articles/read/317/how-to-check-if-a-javascript-promise-has-been-fulfilled-rejected-or-resolved mà dựa câu trả lời của họ trên là có một cách để cho biết nếu một lời hứa ES6 được thực hiện / từ chối / giải quyết?