带延迟的递归函数

Question

我想使用递归函数，但每个函数都应该在 previuse 完成后运行。 所以我写了这段代码：

var service = ['users', 'news'],
    lastSync = {
                 'users' : false,
                 'news' : false
               };
db.transaction(function (tx) {
   lastSyncFunc(tx,service,0).then(function(){
       console.log(lastSync);
   });
});

function lastSyncFunc(tx,service,index){
   deferred = $q.defer();
   tx.executeSql("SELECT time FROM last_sync WHERE fService = ? ORDER BY id DESC LIMIT 1", [service[index]], function (tx, result) {
       if (result.rows.length > 0) {
           lastSync[service[index]] = result.rows.item(0).fTime;
       }
       return ++index<service.length ? lastSyncFunc(tx,service,index) : deferred.resolve();
   });
   return deferred.promise;
}

现在我的程序为lastSync.users 和lastSync.users 返回false，因为在函数完全运行之前运行此部分。

Answer 1

手动处理多个异步调用并不总是最好的决定。
您可以尝试使用$q.all()。

为简单起见，第二步应该是为单个查询编写promisified版本：

const pDbExec = (tx, sql, params = []) => {
  let deferred = $q.defer();
  tx.executeSql(sql, params, (tx, res) => deferred.resolve(res));
  return deferred.promise();
}

第一步应该是“检查我使用的库/方法的承诺版本是否存在”。

然后，只需调用 $q.all 并将您的服务列表映射到承诺：

const SQL_SvcLastSync = `SELECT time FROM ... LIMIT 1`;
db.transaction(tx => {
  $q.all(service.map(svc => pDbExec(tx, SQL_SvcLastSync, [svc])))
    .then(results => 
       results.map(res => 
         res.rows.length > 0 ? res.rows.item(0).fTime : null))
    .then(results => console.log(results));
});

要将结果格式化为键/值对，您有两种选择：

• 添加减速器： .then(results => results.reduce((acc, res, i) => (acc[service[i]]=res, acc), {}))
• 提供键/值（其中值是承诺）而不是数组映射到 $q.all，因此它们将在相同的键下解析。
  当然，您需要修改中间映射器。

---

在递归调用之间添加参数以保存相同的延迟对象的简单解决方案：

试试这样的：

function lastSyncFunc(tx,service,index, def){
   var deferred = def || $q.defer();
   tx.executeSql(
     "SELECT time FROM last_sync WHERE fService = ? ORDER BY id DESC LIMIT 1", 
     [service[index]], 
     function (tx, result) {
       if (result.rows.length > 0) {
           lastSync[service[index]] = result.rows.item(0).fTime;
       }
       return ++index<service.length ? 
         lastSyncFunc(tx,service,index, deferred) : 
         deferred.resolve();
   });
   return deferred.promise;
}

我只是提供延迟到 maxdepth，我们可以在那里解决它。

Answer 2

事实上的方法是避免递归，如“The Collection Kerfuffle”标题下的here 所述。

提倡的模式可以用db.transaction(function() {...}) 结构中的所有内容进行编码，但将tx.executeSql(...) 拉出并在单独的函数中承诺它会更清晰。

你最终会得到这样的结果：

var service = ['users', 'news'],
    lastSync = {
        'users' : false,
        'news' : false
    };
db.transaction(function (tx) {
    return service.reduce(function(promise, serviceItem) {
        return promise.then(function() {
            return executeSqlPromisified(tx, serviceItem).then(function(fTime) {
                if(fTime !== null) {
                    lastSync[serviceItem] = fTime;
                }
            });
        });
    }, $q.when(null)).then(function() {
        console.log(lastSync);
    });
});

function executeSqlPromisified(tx, serviceItem) {
    var deferred = $q.defer();
    tx.executeSql("SELECT time FROM last_sync WHERE fService = ? ORDER BY id DESC LIMIT 1", [serviceItem], function (tx, result) {
        if (result.rows.length) {
            deferred.resolve(result.rows.item(0).fTime);
        } else {
            deferred.resolve(null);
        }
    });
    return deferred.promise;
}

对于未经训练的人来说，这将是非常难以理解的，但相信我，你可以习惯这种模式。