Javascript 挂起异步循环，然后继续处理

我想知道是否有更好的方法来完成这段代码。我正在尝试处理两个文件并保存到数据库中。我想处理订单（父项），完成后再处理子记录。如果数据库正在锁定一些记录，我将等待2秒，然后重试。 我是这样工作的，但我想知道如何才能让它更好。 另外，我不能使用异步-等待

var orderItems = [1, 2, 3];
var tries = 0;

saveOrder()
 .then(function() {
   console.log('Done Order');
   try {
     asyncLoop(orderItems.length, nextItem, success);
   }
   catch(e) { 
     console.log(e); 
   }
 })
 .catch ( console.log );

function nextItem(loop) {
  saveItems(loop.iteration())
  .then((msg) => {
    console.log(loop.iteration());
    loop.next();
  })
  .catch((e) => {
    if (e instanceof String) console.log('Catched !!');
    console.log(e);
    tries = 1;
    waitNTryAgain().then(() => { console.log('Trying again!'); nextItem(loop); });
  });
}

function waitNTryAgain() {
  return new Promise((resolve, reject) => {
    setTimeout( resolve, 2000, 'Done waiting');
  });
}

function success() {
  console.log('Done asyncLoop!');
}

function saveOrder() {
  return new Promise((resolve, reject) => {
    setTimeout(resolve, 2000, 'Save Order Done!');
  });
}

function saveItems(itemNumber) {
  return new Promise((resolve, reject) => {      
      if (itemNumber == 1 && tries == 0) {
        setTimeout(reject, 4000, 'DbLockedException');
      }
      else {
        setTimeout(resolve, 4000, 'Save Item#: ' + itemNumber + ' Done!');
      }     
  })
}

function asyncLoop(iterations, func, callback) {
  var index = 0;
  var done = false;
  var loop = {
               next: function() {
                      if (done) return;    

                      if (index < iterations) {
                        index++;
                        func(loop);
                      } 
                      else {
                        done = true;
                        callback();
                      }
                    },
               iteration: function() {
                 return index - 1;
               },    
               break: function() {
                 done = true;
                 callback();
               }
             };
  loop.next();
  return loop;
}

var orderItems=[1,2,3]；
var=0；
保存顺序（）
.然后（函数（）{
console.log（'Done Order'）；
试一试{
asyncLoop（orderItems.length、nextItem、success）；
}
第（e）款{
控制台日志（e）；
}
})
.catch（console.log）；
函数nextItem（循环）{
保存项（loop.iteration（））
。然后（（msg）=>{
log（loop.iteration（））；
loop.next（）；
})
.catch（（e）=>{
if（e instanceof String）console.log（'Catched！！'）；
控制台日志（e）；
尝试=1；
waitNTryAgain（）.then（（）=>{console.log（'Trying reach！'）；nextItem（loop）；}）；
});
}
函数waitNTryAgain（）{
返回新承诺（（解决、拒绝）=>{
setTimeout（解析，2000，“完成等待”）；
});
}
函数成功（）{
log（'Done asyncLoop！'）；
}
函数saveOrder（）{
返回新承诺（（解决、拒绝）=>{
setTimeout（解析，2000，“保存订单完成！”）；
});
}
函数saveItems（itemNumber）{
返回新承诺（（解决，拒绝）=>{
if（itemNumber==1&&trys==0）{
setTimeout（拒绝，4000，'dblockedeException'）；
}
否则{
setTimeout（解析，4000，“保存项目：”+itemNumber+“完成！”）；
}     
})
}
函数asyncLoop（迭代、func、回调）{
var指数=0；
var done=false；
变量循环={
下一步：函数（）{
如果（完成）返回；
如果（索引<迭代次数）{
索引++；
func（loop）；
} 
否则{
完成=正确；
回调（）；
}
},
迭代：函数（）{
回报指数-1；
},    
中断：函数（）{
完成=正确；
回调（）；
}
};
loop.next（）；
回路；
}

我能做的最好的改进就是创建一个模块模式：

var AsyncProc=（函数（）{
返回{
订单项：[1,2,3]，
尝试次数：0，
init:function（）
{
这是saveOrder（）
.然后（（）=>{
console.log（'Done Order'）
尝试
{
this.asyncLoop（this.orderItems.length、this.nextItem.bind（this）、this.success）
}
catch（e）{console.log（e）}
})
.catch（console.log）；
},
保存顺序：函数（）
{
返回新承诺（（解决、拒绝）=>{
setTimeout（解析，2000，“保存订单完成！”）
})
},
nextItem：函数（循环）
{
此.saveItems（loop.iteration（））
。然后（（msg）=>{
console.log（loop.iteration（））
loop.next（）；
})
.catch（（e）=>{
控制台日志（e）；
这是1；
这是waitNTryAgain（）。
然后（（）=>{console.log（'Trying reach！'）；this.nextItem（循环）；}）
})
},
waitNTryAgain:function（）
{
返回新承诺（（解决、拒绝）=>{
setTimeout（解析，2000，“完成等待”）
})
},
saveItems:函数（itemNumber）
{
返回新承诺（（解决、拒绝）=>{
if（itemNumber==1&&this.trys==0）
{
setTimeout（拒绝，4000，'dblockedeException'）；
}
其他的
{
setTimeout（解析，4000，“保存项目：”+itemNumber+“完成！”）；
} 
});
},    
成功：函数（）
{
log（'Done asyncLoop！'）
},    
asyncLoop：函数（迭代、func、回调）
{
var指数=0；
var done=false；
变量循环=
{
下一步：函数（）
{
如果（完成）返回；
如果（索引<迭代次数）
{
索引++；
func（loop）；
} 
其他的
{
完成=正确；
回调（）；
}
},
迭代：函数（）
{
回报指数-1；
},
中断：函数（）
{
完成=正确；
回调（）；
}
};
loop.next（）；
回路；
}	    
};
})();
AsyncProc.init（）我能做的最好的改进就是创建一个模块模式：


var AsyncProc=（函数（）{
返回{
订单项：[1,2,3]，
尝试次数：0，
init:function（）
{
这是saveOrder（）
.然后（（）=>{
console.log（'Done Order'）
尝试
{
this.asyncLoop（this.orderItems.length、this.nextItem.bind（this）、this.success）
}
catch（e）{console.log（e）}
})
.catch（console.log）；
},
保存顺序：函数（）
{
返回新承诺（（解决、拒绝）=>{
setTimeout（解析，2000，“保存订单完成！”）
})
},
nextItem：函数（循环）
{
此.saveItems（loop.iteration（））
。然后（（msg）=>{
console.log（loop.iteration（））
loop.next（）；
})
.catch（（e）=>{
控制台日志（e）；
这是1；
这是waitNTryAgain（）。
然后（（）=>{console.log（'Trying reach！'）；this.nextItem（循环）；}）
})
},
waitNTryAgain:function（）
{
返回新承诺（（解决、拒绝）=>{
setTimeout（解析，2000，“完成等待”）
})
},
saveItems:函数（itemNumber）
{
返回新承诺（（解决、拒绝）=>{
if（itemNumber==1&&this.trys==0）
{
设置超时（re）