JSfunction arrang(name){ const task = []; task.push(() => {

链式调用

function arrang(name){
    const task = [];
    task.push(() => {
        console.log(`${name} is notified`);
    })
    
    function wait(time){
        task.push(() => {
            // 包到 promise 里面是因为等待完后才能执行下面的任务 
            new Promise(resolve => {
                setTimeout(() => resolve, time * 1000)
            })
            console.log(`等待${time}秒-`)
        })
        return this;
    }
    
    function doSomething(taskName){
        task.push(() => {
            console.log(`start to ${taskName}`)
        })
        return this;
    }
    
    function waitFirst(time){
        task.unshift(() => {
            new Promise(resolve => {
                setTimeout(() => resolve, time * 1000)
            })
            console.log(`等待${time}秒`)
        })
        return this;
    }
    
    async function execute() {
        for(let t of task){
            await t();
        }
        return this;
    }

    return {
        wait,
        do: doSomething,
        waitFirst,
        execute
    }
}

arrange('aaa')
    .wait(5)
    .do('commit')
    .execute();

Promise.retry

Promise._retry = function (fn, time, delay) {
  let count = 0
  return new Promise((resolve, reject) => {
    function retry () {
      fn().then(res => {
        resolve(res)
      }, error => {
        count++
        if (count < time) {
          setTimeout(() => {
            console.log(`第${count}/${time}次请求`)
            retry()
          }, delay)
        } else {
          reject(new Error(`请求失败，以尝试${count}次`))
        }
      })
    }
    
    retry()
  })
}


// 示例：模拟一个可能失败的异步操作
const asyncOperation = () => {
  const random = Math.random();
  if (random < 0.3) {
    return Promise.resolve('Operation succeeded');
  } else {
    return Promise.reject(new Error('Operation failed'));
  }
};

// 使用 retryPromise 函数
Promise._retry(asyncOperation, 3, 2000)
.then((result) => {
  console.log(result);
})
.catch((error) => {
  console.error(error.message);
});