How to handle multiple promises in AngularJS_AngularJS

When using AngularJS to handle promises, sometimes you will encounter situations where you need to handle multiple promises.

The simplest solution is to have then for every promise. As follows:

var app = angular.module("app",[]);
app.controller("AppCtrl", function($q. $timeout){
var one = $q.defer();
var two = $q.defer();
var three = $q.defer();
$timeout(function(){
one.resolve("one done");
}, Math.random() * 1000)
$timeout(function(){
two.resolve("two done");
}, Math.random() * 1000) 
$timeout(function(){
three.resolve("three done");
}, Math.random() * 1000) 
functioin success(data){
console.log(data);
}
one.promise.then(success);
two.promise.then(success);
three.promise.then(success);
})

Is there a better way?

The $q.all method can accept an array of promises and is called as follows:

var all = $q.all([one.promise, two.promise, three.promise]);
all.then(success);

What is promise?

Promise is a method of processing values ​​asynchronously. Promise is an object, which represents the final possible return value or exception thrown by a function. When dealing with remote objects, we can regard them as remote objects. of an agent. If promise is also a kind of asynchronous processing method, then we will think of its difference from XHR and $.ajax?

It is customary for js to use closures or callbacks to respond to asynchronously returned data, such as XHR requests after the page is loaded. We can interact with the data normally as if it had been returned without relying on the triggering of the callback function.

So what problem is the promise proposed by ng intended to solve? Callbacks have been used for a long time, and usually debugging becomes very difficult if there are callbacks that depend on other callbacks, and errors need to be displayed after each call. The difference is that promises provide another abstraction: these functions return promise objects.

Why use promise

One of the benefits of using promises is that you escape the fixed thinking logic of callbacks. Promise makes the asynchronous processing mechanism look more like synchronization. Based on synchronous functions, we can capture return values ​​and exception values ​​as expected. Errors can be caught at any moment in the program and bypass subsequent code that relies on program exceptions. We don't need to think about the benefits of this synchronization. Therefore, the purpose of using promises is to obtain functional combination and error bubbling capabilities while maintaining the ability to run the code asynchronously.

Promise is a first-class object and comes with some conventions.

• Only one resolve or reject will be called.

• If a promise is executed or rejected, handlers that depend on them will still be called.

• Handlers are always called asynchronously.