实现异步队列

使多个异步任务按照压入栈的顺序先后执行

export class AsyncQueue {
  static create(name) {
    return new this(name);
  }

  constructor(name) {
    this.name = name;
    // 任务队列
    this.queue = [];
    // 是否有任务正常执行
    this.running = false;
  }

  push(fun) {
    return new Promise((resovle, reject) => {
      // 将 fun 包装一层放进任务队列中
      this.queue.push(async () => {
        this.running = true;
        try {
          const res = await fun();
          resovle(res);
        } catch (e) {
          reject(e);
        }

        this.running = false;
        // 获取下一个任务并执行
        const next = this.queue.shift();
        next?.();
      });
      // 若当前未有任务执行中，则触发队列的执行
      if (!this.running) {
        this.queue.shift()?.();
      }
    });
  }
}

场景

当触发多个弹窗时，按照触发顺序，在前一个弹窗执行完成后执行下一个弹窗。

以 uniapp 为例,先封装一个异步弹窗

// utils.js

export const promiseDialog = async (dialogProps) => {
  const {
    cancelResultType = 'resolve',
    confirmResultType = 'resolve',
    onConfirm = () => 'confirm',
    onCancel = () => 'cancel',
    ...modalProps
  } = dialogProps;

  return new Promise((resolve, reject) => {
    uni.showModal({
      ...modalProps,
      success: async (res) => {
        if (res.confirm) {
          const confirmValue = await onConfirm();
          confirmResultType === 'resolve'
            ? resolve(confirmValue)
            : reject(confirmValue);
        } else if (res.cancel) {
          const cancelValue = await onCancel();
          cancelResultType === 'resolve'
            ? resolve(cancelValue)
            : reject(cancelValue);
        }
      },
    });
  });
};

使用

import {promiseDialog,AsyncQueue} from '@/utils'
const asyncQueue = AsyncQueue.create();
await asyncQueue.push(() => {
  return promiseDialog({
    title: `promise-1`,
    onConfirm() {
      console.log('promise-1');
    },
  });
});
console.log('await promise-1');
for (let i = 0; i < 5; i++) {
  asyncQueue.push(() => {
    return promiseDialog({
      title: `task-${i}`,
    });
  });
  console.log(i);
}