Javascript 将模块变量切换为实例变量

我制作了一个用于并发异步/等待函数处理的模块，类似于npm模块“异步”，只是没有回调

我让它工作到：

module.exports = function () {
  module.internalQueue = []
  module.func = undefined
  module.parallelism =  1

  const process = async () => {
      const pickUpNextTask = () => {
        if (module.internalQueue.length) {
          return module.func(module.internalQueue.shift())
        }
      }
      const startChain = () => {
        return Promise.resolve().then(function next() {
          return pickUpNextTask().then(next)
        })
      }
      let chains = []
      for (let k = 0; k < module.parallelism; k += 1) {
        chains.push(startChain());
      }
      await Promise.all(chains)
      module.drain()
  }

  module.queue = (func, parallelism = 1) => {
    module.func = func
    module.parallelism = parallelism
    return module
  }

  module.push = async (customers) => {
    module.internalQueue.push(customers)
    await process()
  }

  module.drain = () => {}

  return module
}

module.exports=函数（）{
module.internalQueue=[]
module.func=未定义
module.parallelism=1
const进程=异步（）=>{
常量pickUpNextTask=（）=>{
if（module.internalQueue.length）{
返回module.func（module.internalQueue.shift（））
}
}
常量起始链=（）=>{
返回Promise.resolve（）.then（函数next（））{
返回pickUpNextTask（）。然后（下一步）
})
}
让链=[]
for（设k=0；k{
module.func=func
module.parallelism=并行
返回模块
}
module.push=异步（客户）=>{
module.internalQueue.push（客户）
等待进程（）
}
module.drain=（）=>{}
返回模块
}

我相信当只有一个队列时，我的解决方案会起作用。如果存在多个队列，则竞争将终止代码

我试图将其重构为一个对象：

class async extends Object {
  constructor() {
    this.internalQueue = []
    this.propertyIsEnumerable = 1
    this.func = undefined
    this.drain = () => {}
  }

  static queue(func, parallelism = 1) {
    const o = new async.constructor()
    o.func = func
    o.parallelism = parallelism
    return o
  }

  async push(q) {
    this.internalQueue.push(q)
    await process()
  }

  async process() {
    const pickUpNextTask = () => {
      if (this.internalQueue.length) {
        return this.func(this.internalQueue.shift())
      }
    }
    const startChain = () => {
      return Promise.resolve().then(function next() {
        return pickUpNextTask().then(next)
      })
    }
    let chains = []
    for (let k = 0; k < this.parallelism; k += 1) {
      chains.push(startChain());
    }
    await Promise.all(chains)
    this.drain()
  }
}

类异步扩展对象{
构造函数（）{
this.internalQueue=[]
this.propertyEnumerable=1
this.func=未定义
this.drain=（）=>{}
}
静态队列（func，并行度=1）{
const o=new async.constructor（）
o、 func=func
o、 平行度=平行度
返回o
}
异步推送（q）{
this.internalQueue.push（q）
等待进程（）
}
异步进程（）{
常量pickUpNextTask=（）=>{
if（this.internalQueue.length）{
返回this.func（this.internalQueue.shift（））
}
}
常量起始链=（）=>{
返回Promise.resolve（）.then（函数next（））{
返回pickUpNextTask（）。然后（下一步）
})
}
让链=[]
for（设k=0；k

是否可能有一个静态方法调用构造函数并返回对象？如果是，请共享指针

---

谢谢

别把事情弄得太复杂了。只需将值保存在局部变量中，而不是将它们放在

模块中。你不需要一个
类

module.exports = function queue(func, parallelism = 1) {
  var internalQueue = []

  async function process() {
    function pickUpNextTask() {
      if (internalQueue.length) {
        return func(internalQueue.shift())
      }
    }
    async function startChain() {
      while (true) // I don't think this is what you want
        await pickUpNextTask();
    }
    let chains = []
    for (let k = 0; k < parallelism; k += 1) {
      chains.push(startChain());
    }
    await Promise.all(chains)
    drain()
  }
  function drain() {}

  return async function push(customers) {
    internalQueue.push(customers)
    await process() // I don't think this is what you want
  }
}

module.exports=函数队列（func，并行度=1）{
var internalQueue=[]
异步函数进程（）{
函数pickUpNextTask（）{
if（internalQueue.length）{
return func（internalQueue.shift（））
}
}
异步函数startChain（）{
while（true）//我认为这不是你想要的
等待pickUpNextTask（）；
}
让链=[]
for（设k=0；k<平行度；k+=1）{
链。推（启动链（））；
}
等待承诺。所有（锁链）
排水管（）
}
函数drain（）{}
返回异步函数推送（客户）{
internalQueue.push（客户）
wait process（）//我认为这不是你想要的
}
}
在您的示例中，
push
不会像我需要的那样工作。如果您的解决方案更改为：``module.push=async function（customers）{internalQueue.push（customers）wait process（）//我认为这不是您想要的}return module``再次，我们的
push（）
工作正常，但队列是共享的。顺便说一句，@Bergi-非常感谢您的建议。@MosheShmukler也许您想执行
返回{push:async function（）{…}？不要使用
模块
，用你想公开的东西创建你自己的对象。