Promise's chaining, is there any better way?

Question

I have demonstrated promise chaining where promise's p1,p2,p3 has to be resolved synchronously.

The code below is using angular.js 1, and here P3 is resolved then P2 and then P1.

the code is as follows,

<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>

So, my question is, Is there any better way of doing the above operation ? Also please review my code. Thanks.

If there's no bug and you just want a code review, it's probably better to ask on https://codereview.stackexchange.com/ — ADyson, Feb 01 '18 at 10:21
Possible duplicate of [Resolve promises one after another (i.e. in sequence)?](https://stackoverflow.com/questions/24586110/resolve-promises-one-after-another-i-e-in-sequence) — Andreas, Feb 01 '18 at 10:23
`p1,p2,p3 has to be resolved synchronously` - synchronously, or serially? Former is not possible, latter is — Jaromanda X, Feb 01 '18 at 10:33
JavaScript by itself has its limitation. TypeScript offers async/await functionality, what allows you to write async calls in a synchronous way. But using this, would force you to set up a build pipeline in any way. So, maybe not what you are looking for. — scipper, Feb 01 '18 at 15:04

T.J. Crowder · Accepted Answer · 2018-02-01T10:47:21.947

where promise's p1,p2,p3 has to be resolved synchronously

Those promises will not be resolved synchronously, or serially (if that's what you meant).

A promise doesn't control the asynchronous action, it just represents the result. So by doing this:

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

...you've already started the actions, which will run in parallel (although in your case, as they all just schedule timer callbacks on the main thread, they'll get serialized by contention for that one thread).

If you want to do one thing, wait for it to finish, and then do the next (e.g., do them in series, aka serially), you build a chain:

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

Of course, if you want all three results at the end, you have to make result1 and result2 available to the third callback in any of several ways.

Promise's chaining, is there any better way?

1 Answers1