Javascript 承诺'；有没有更好的方法？

我已经演示了承诺链，承诺的p1、p2、p3必须同步解析

下面的代码使用angular.js 1，这里解析P3，然后解析P2，然后解析P1

代码如下：

<script type="text/javaScript">
            angular.module("myApp",[]);
            angular.module("myApp").controller("myCtrl",myCtrl);
            angular.module("myApp").factory("demoService",demoService);

            demoService.$inject = ["$q","$timeout"];
            myCtrl.$inject = ["$scope","demoService"];

            function myCtrl($scope,demoService){
                var vm = this;
                vm.init = init;

                vm.myList = [];

                function init(){
                    var p1 = demoService.get1000();
                    var p3 = demoService.get3000(); 
                    var p2 = demoService.get2000();

                    p3.then(function(obj){
                        console.log(obj.name);                      
                        return p2;
                    }).then(function(obj){
                        console.log(obj.name);
                        return p1;
                    }).then(function(obj){
                        console.log(obj.name);
                    }); 
                } // end of init
            } // end of myCtrl  

            function demoService($q,$timeout){
                var obj = {};
                obj.get1000 = get1000;
                obj.get2000 = get2000;
                obj.get3000 = get3000;

                return obj;

                function get1000(){
                    var deferred = $q.defer();
                    var INTERVAL = 1000;
                    $timeout(function() {                       
                        deferred.resolve({ "name" : INTERVAL });
                    }, INTERVAL);
                    return deferred.promise;
                }

                function get2000(){
                    var deferred = $q.defer();
                    var INTERVAL = 2000;
                    $timeout(function() {
                        deferred.resolve({ "name" : INTERVAL });
                    }, INTERVAL);
                    return deferred.promise;
                }

                function get3000(){
                    var deferred = $q.defer();
                    var INTERVAL = 3000;
                    $timeout(function() {
                        deferred.resolve({ "name" : INTERVAL });
                    }, INTERVAL);
                    return deferred.promise;
                }

            } // end of demoService 
</script>

angular.module（“myApp”，[]）；
角度.module（“myApp”）.controller（“myCtrl”，myCtrl）；
角度。模块（“myApp”）。工厂（“demoService”，demoService）；
demoService.$inject=[“$q”，“$timeout”]；
myCtrl.$inject=[“$scope”，“demoService”]；
函数myCtrl（$scope，demoService）{
var vm=这个；
vm.init=init；
vm.myList=[]；
函数init（）{
var p1=demoService.get1000（）；
var p3=demoService.get3000（）；
var p2=demoService.get2000（）；
p3.然后（功能（obj）{
控制台日志（对象名称）；
返回p2；
}).然后（功能（obj）{
控制台日志（对象名称）；
返回p1；
}).然后（功能（obj）{
控制台日志（对象名称）；
}); 
}//初始化结束
}//myCtrl结束
函数demoService（$q，$timeout）{
var obj={}；
obj.get1000=get1000；
obj.get2000=get2000；
obj.get3000=get3000；
返回obj；
函数get1000（）{
var deferred=$q.deferred（）；
var区间=1000；
$timeout（函数（）{
解析（{“name”：INTERVAL}）；
}，间隔）；
回报。承诺；
}
函数get2000（）{
var deferred=$q.deferred（）；
var区间=2000；
$timeout（函数（）{
解析（{“name”：INTERVAL}）；
}，间隔）；
回报。承诺；
}
函数get3000（）{
var deferred=$q.deferred（）；
var区间=3000；
$timeout（函数（）{
解析（{“name”：INTERVAL}）；
}，间隔）；
回报。承诺；
}
}//服务结束

那么，我的问题是，有没有更好的方法来进行上述操作？ 也请检查我的代码。 谢谢

其中，承诺的p1、p2、p3必须同步解析

这些承诺不会同步或连续地解决（如果这是你的意思的话）

承诺并不控制异步操作，它只表示结果。因此，通过这样做：

var p1 = demoService.get1000();
var p3 = demoService.get3000(); 
var p2 = demoService.get2000();

…您已经启动了操作，这些操作将并行运行（尽管在您的情况下，由于它们都只是在主线程上调度计时器回调，它们将通过争用该线程而序列化）

如果您想做一件事，等待它完成，然后再做下一件事（例如，按系列进行，也称为按系列进行），您将构建一个链：

demoService.get1000()
    .then(result1 => demoService.get3000())
    .then(result2 => demoService.get2000())
    .then(result3 => {
        // Do something with the result
    })
    .catch(error => {
        // Do something with the error
    });

当然，如果希望在最后显示所有三个结果，则必须以几种方式中的任意一种方式使第三个回调可以使用

result1

和

result2

其中，承诺的p1、p2、p3必须同步解析

这些承诺不会同步或连续地解决（如果这是你的意思的话）

承诺并不控制异步操作，它只表示结果。因此，通过这样做：

var p1 = demoService.get1000();
var p3 = demoService.get3000(); 
var p2 = demoService.get2000();

…您已经启动了操作，这些操作将并行运行（尽管在您的情况下，由于它们都只是在主线程上调度计时器回调，它们将通过争用该线程而序列化）

如果您想做一件事，等待它完成，然后再做下一件事（例如，按系列进行，也称为按系列进行），您将构建一个链：

demoService.get1000()
    .then(result1 => demoService.get3000())
    .then(result2 => demoService.get2000())
    .then(result3 => {
        // Do something with the result
    })
    .catch(error => {
        // Do something with the error
    });

---

当然，如果你想在最后得到所有三个结果，你必须以多种方式让第三次回调可以使用

result1

和

result2

。

如果没有bug，你只想查看代码，最好询问

p1，p2的可能重复项，p3必须同步解析

——同步解析还是串行解析？前者是不可能的，后者本身就有其局限性。TypeScript提供异步/等待功能，允许您以同步方式编写异步调用。但是使用它，将迫使您以任何方式建立构建管道。所以，可能不是你想要的。如果没有bug，你只是想检查一下代码，那么最好询问一下p1、p2、p3的可能重复项是否必须同步解决，同步还是串行解决？前者是不可能的，后者本身就有其局限性。TypeScript提供异步/等待功能，允许您以同步方式编写异步调用。但是使用它，将迫使您以任何方式建立构建管道。所以，也许不是你想要的。