链接多个承诺(处理回调)

Chaining multiple promises (handling callbacks)

本文关键字:处理 回调 承诺 链接      更新时间:2023-09-26

当链接多个承诺时,我在承诺方面遇到了一些困难。困惑在于如何正确利用承诺&它们与回调的差异。我注意到,无论承诺是否得到解决,回调有时都会触发,这使得以下实现不可靠。。(除非我的语法和逻辑错误)
我阅读了官方文档并提出了这个想法,但我不确定它是否得到了很好的实现

注册流程如下:

  • 用户选择别名->详细信息Alias+userID(设备的通用唯一标识符)发送到服务器端
  • 如果Alias可用,则生成ApiKey(令牌),用户注册并发送回客户端(存储在DB中)

Services.js

(function(angular) {
   myApp.factory("deviceDB.Service", ['$resource', '$http', '$q',
   function ($resource,  $http , $q ) {
    return {
//Second Promsie : After API token is generated server-side, store res in db
        RegDevice: function (alias, apiKey, userID) { 
            var deferred = $q.defer();
            var configuration ;
            var db = window.sqlitePlugin.openDatabase({name: "config.db"});
            setTimeout(function () {
                db.transaction(function (tx) {
                    tx.executeSql('CREATE TABLE IF NOT EXISTS user_details (userID UNIQUE , alias TEXT, apiKey TEXT)');
                    tx.executeSql("INSERT INTO user_details (userID, alias, apiKey) VALUES (?,?,?)", [userID, alias, apiKey], function (tx, res) {
                        deferred.resolve(configuration = true);
                    }, function (e) {
                        // console.log("ERROR: " + e.message);
                        deferred.reject(configuration = false);
                    });
                });
            }, 1000);
            return deferred.promise;
        },
//First Promsie: Register user  server side & generate APi token
        RegUser: function (alias, userID) { 
            var deferred = $q.defer();
            var pro;
            pro = $resource('api/query/register', {'alias': alias, 'userID': userID},
                { query: {
                        isArray: false,
                        method: 'GET'  } });
            setTimeout(function () {
                pro.query(function (res) {
                    if (res.error) {
                        deferred.reject( { error : res.error, exists: res.exists,  msg: res.message } );
                    }
                    else {
                        deferred.resolve( {error : res.error , alias: res.alias , apiKey: res.apiKey, msg: res.message } );
                    }
                }, function (e) {
                    deferred.reject( { errorStatus: e.status } );
                });
            }, 1000);
            return deferred.promise;
        }
    };
  }]);
}(window.angular));


现在,在我的控制器中,我想把上面的两个承诺都链接起来。我引用文档中的以下内容:

then(successCallback, errorCallback, notifyCallback)–无论何时解决或拒绝承诺,只要结果可用,就会异步调用其中一个成功或错误回调。回调是用一个参数调用的:结果或拒绝原因。此外,在承诺被解决或拒绝之前,通知回调可以被调用零次或多次以提供进度指示。

  1. 如果无论承诺是否得到解决,他们都可以开火,那么召回有什么意义
  2. 我不应该在第一次Promise的成功回调中调用例如Promise2吗?如果它被激发而不管Promise1是否被解决,那么我如何才能以只有当Promise1被解决时才激发的方式来连锁Promise2


我尝试了什么:
Controller.js

myApp.controller('RegisterController', ['$scope', '$http', 'deviceDB.Service',
    function ($scope , $http , deviceDB.Service) {
   var Promise1 = deviceDB.RegUser($scope.alias, $scope.Device); 
// First promise - Validate with server
   Promise1.then(function(data)
                    {
                        console.log(' Registration Server-Side successfully');
                        $scope.apiKey = data.apiKey;
                        term.echo(data.apiKey);
                    }, function(e)
                    {
                        console.log('Registration Failed');
                        term.echo(e.msg);
                    })
//Call Promise 2 & Store details Client-Side using .then()
    .then(deviceDB.RegDevice($scope.alias, $scope.apiKey, $scope.Device), 
     function(d){
                       console.log('Items Stored in DB successfully');
                    }, function()
                    {
                        console.log('Items Stored in DB Failed');
                    });
  }]);

注意:我知道在客户端存储详细信息是一种糟糕的做法,但是,我追求的是一个不同的概念(匿名消息),并且没有安全问题

感谢您抽出时间

在之后,您的第二次通话似乎不正确

//Call Promise 2 & Store details Client-Side using .then()

then最多需要3个参数then(successCallback, errorCallback, notifyCallback),您正在传递它:deviceDB.RegDevice($scope.alias, $scope.apiKey, $scope.Device),它会立即求值,返回的promise会作为成功函数传递给函数then,您的成功函数会作为errorCallback传递,您的失败函数会作为notifyCallback传递。

我会试试下面的

 Promise1.then(function(data)
 {
   console.log(' Registration Server-Side successfully');
   $scope.apiKey = data.apiKey;
   term.echo(data.apiKey);
   return deviceDB.RegDevice($scope.alias, $scope.apiKey, $scope.Device)
 }, function(e)
 {
   console.log('Registration Failed');
   term.echo(e.msg);
   return e;
 }).then(function(d) {/*all good*/}, function(e) {/* all bad */}

请注意,对RegDevice的调用现在在一个函数块中,并且从您想要链接的then块返回promise。

我发现$q.serial是一个很好的链接承诺库。它很容易使用,可以处理很多事情,比如检查链上的所有承诺是否真的是承诺。

这里有一个小例子:

function do_all() {                                                         
    var task_1 = function() {                                                  
        return $http.get("some url")                                           
            .then(on_xhr_completed_fn, on_xhr_failed_fn);                      
    }                                                                          
    var task_2 = function(some_data) {                                         
        vm.bla = some_data;                                                    
        return $http.get("other url")                                          
            .then(on_xhr_completed_fn, on_xhr_failed_fn);                      
    }                                                                          
    var task_3 = function(other_data) {                                        
        vm.bli = other_data;                                                   
    }                                                                       
    var tasks = [task_1, task_2, task_3];                                      
    return $q.serial(tasks)                                                    
        .then(function() {                                                     
            console.log("Finished tasks 1, 2 and 3!!!");                       
        });                                                                    
}  

以下是一种使用async/await可能有用的方法:

async function run_promise_A(args) {
    return new Promise((resolve, reject) => {
        return resolve(resolve_value)
    });
}
async function run_promise_B(args) {
    return new Promise((resolve, reject) => {
        return resolve(resolve_value)
    });
}
async function run_promise_C(args) {
    return new Promise((resolve, reject) => {
        return resolve(resolve_value)
    });
}
async function run_several_async_functions(userid) {
    let a = run_promise_A(userid);
    let b = run_promise_B(a);
    let c = run_promise_C(b);
    return c;
}
return Promise.resolve()
    .then(() => {
        let c = (async () => {
            let c = await run_several_async_functions(userid)
            return c;
        })();
        return c;
    })
    .then((c) => {
        return c;
    })
    .catch((err) => {
        console.log(err);
    });