A service that helps you run functions asynchronously, and use their return values (or exceptions) when they are done processing.
This is an implementation of promises/deferred objects inspired by Kris Kowal's Q.
$q can be used in two fashions --- one which is more similar to Kris Kowal's Q or jQuery's Deferred implementations, and the other which resembles ES6 (ES2015) promises to some degree.
The streamlined ES6 style promise is essentially just using $q as a constructor which takes a resolver
function as the first argument. This is similar to the native Promise implementation from ES6,
see MDN.
While the constructor-style use is supported, not all of the supporting methods from ES6 promises are available yet.
It can be used like so:
// for the purpose of this example let's assume that variables `$q` and `okToGreet`
// are available in the current lexical scope (they could have been injected or passed in).
function asyncGreet(name) {
// perform some asynchronous operation, resolve or reject the promise when appropriate.
return $q(function(resolve, reject) {
setTimeout(function() {
if (okToGreet(name)) {
resolve('Hello, ' + name + '!');
} else {
reject('Greeting ' + name + ' is not allowed.');
}
}, 1000);
});
}
var promise = asyncGreet('Robin Hood');
promise.then(function(greeting) {
alert('Success: ' + greeting);
}, function(reason) {
alert('Failed: ' + reason);
});
Note: progress/notify callbacks are not currently supported via the ES6-style interface.
Note: unlike ES6 behavior, an exception thrown in the constructor function will NOT implicitly reject the promise.
However, the more traditional CommonJS-style usage is still available, and documented below.
The CommonJS Promise proposal describes a promise as an interface for interacting with an object that represents the result of an action that is performed asynchronously, and may or may not be finished at any given point in time.
From the perspective of dealing with error handling, deferred and promise APIs are to
asynchronous programming what try
, catch
and throw
keywords are to synchronous programming.
// for the purpose of this example let's assume that variables `$q` and `okToGreet`
// are available in the current lexical scope (they could have been injected or passed in).
function asyncGreet(name) {
var deferred = $q.defer();
setTimeout(function() {
deferred.notify('About to greet ' + name + '.');
if (okToGreet(name)) {
deferred.resolve('Hello, ' + name + '!');
} else {
deferred.reject('Greeting ' + name + ' is not allowed.');
}
}, 1000);
return deferred.promise;
}
var promise = asyncGreet('Robin Hood');
promise.then(function(greeting) {
alert('Success: ' + greeting);
}, function(reason) {
alert('Failed: ' + reason);
}, function(update) {
alert('Got notification: ' + update);
});
At first it might not be obvious why this extra complexity is worth the trouble. The payoff comes in the way of guarantees that promise and deferred APIs make, see https://github.com/kriskowal/uncommonjs/blob/master/promises/specification.md.
Additionally the promise api allows for composition that is very hard to do with the traditional callback (CPS) approach. For more on this please see the Q documentation especially the section on serial or parallel joining of promises.
A new instance of deferred is constructed by calling $q.defer()
.
The purpose of the deferred object is to expose the associated Promise instance as well as APIs that can be used for signaling the successful or unsuccessful completion, as well as the status of the task.
Methods
resolve(value)
– resolves the derived promise with the value
. If the value is a rejection
constructed via $q.reject
, the promise will be rejected instead.reject(reason)
– rejects the derived promise with the reason
. This is equivalent to
resolving it with a rejection constructed via $q.reject
.notify(value)
- provides updates on the status of the promise's execution. This may be called
multiple times before the promise is either resolved or rejected.Properties
{Promise}
– promise object associated with this deferred.A new promise instance is created when a deferred instance is created and can be retrieved by
calling deferred.promise
.
The purpose of the promise object is to allow for interested parties to get access to the result of the deferred task when it completes.
Methods
then(successCallback, errorCallback, notifyCallback)
– regardless of when the promise was or
will be resolved or rejected, then
calls one of the success or error callbacks asynchronously
as soon as the result is available. The callbacks are called with a single argument: the result
or rejection reason. Additionally, the notify callback may be called zero or more times to
provide a progress indication, before the promise is resolved or rejected.
This method returns a new promise which is resolved or rejected via the return value of the
successCallback
, errorCallback
(unless that value is a promise, in which case it is resolved
with the value which is resolved in that promise using
promise chaining).
It also notifies via the return value of the notifyCallback
method. The promise cannot be
resolved or rejected from the notifyCallback method.
catch(errorCallback)
– shorthand for promise.then(null, errorCallback)
finally(callback, notifyCallback)
– allows you to observe either the fulfillment or rejection of a promise,
but to do so without modifying the final value. This is useful to release resources or do some
clean-up that needs to be done whether the promise was rejected or resolved. See the full
specification for
more information.
Because calling the then
method of a promise returns a new derived promise, it is easily
possible to create a chain of promises:
promiseB = promiseA.then(function(result) {
return result + 1;
});
// promiseB will be resolved immediately after promiseA is resolved and its value
// will be the result of promiseA incremented by 1
It is possible to create chains of any length and since a promise can be resolved with another promise (which will defer its resolution further), it is possible to pause/defer resolution of the promises at any point in the chain. This makes it possible to implement powerful APIs like $http's response interceptors.
There are two main differences:
$rootScope.Scope
Scope model observation
mechanism in angular, which means faster propagation of resolution or rejection into your
models and avoiding unnecessary browser repaints, which would result in flickering UI.it('should simulate promise', inject(function($q, $rootScope) {
var deferred = $q.defer();
var promise = deferred.promise;
var resolvedValue;
promise.then(function(value) { resolvedValue = value; });
expect(resolvedValue).toBeUndefined();
// Simulate resolving of promise
deferred.resolve(123);
// Note that the 'then' function does not get called synchronously.
// This is because we want the promise API to always be async, whether or not
// it got called synchronously or asynchronously.
expect(resolvedValue).toBeUndefined();
// Propagate promise resolution to 'then' functions using $apply().
$rootScope.$apply();
expect(resolvedValue).toEqual(123);
}));
$q(resolver);
Param | Type | Details |
---|---|---|
resolver | function(function, function) |
Function which is responsible for resolving or rejecting the newly created promise. The first parameter is a function which resolves the promise, the second parameter is a function which rejects the promise. |
Promise | The newly created promise. |
Creates a Deferred
object which represents a task which will finish in the future.
Deferred | Returns a new instance of deferred. |
Creates a promise that is resolved as rejected with the specified reason
. This api should be
used to forward rejection in a chain of promises. If you are dealing with the last promise in
a promise chain, you don't need to worry about it.
When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of
reject
as the throw
keyword in JavaScript. This also means that if you "catch" an error via
a promise error callback and you want to forward the error to the promise derived from the
current promise, you have to "rethrow" the error by returning a rejection constructed via
reject
.
promiseB = promiseA.then(function(result) {
// success: do something and resolve promiseB
// with the old or a new result
return result;
}, function(reason) {
// error: handle the error if possible and
// resolve promiseB with newPromiseOrValue,
// otherwise forward the rejection to promiseB
if (canHandle(reason)) {
// handle the error and recover
return newPromiseOrValue;
}
return $q.reject(reason);
});
Param | Type | Details |
---|---|---|
reason | * |
Constant, message, exception or an object representing the rejection reason. |
Promise | Returns a promise that was already resolved as rejected with the |
when(value, [successCallback], [errorCallback], [progressCallback]);
Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
Param | Type | Details |
---|---|---|
value | * |
Value or a promise |
successCallback
(optional)
|
Function= | |
errorCallback
(optional)
|
Function= | |
progressCallback
(optional)
|
Function= |
Promise | Returns a promise of the passed value or promise |
resolve(value, [successCallback], [errorCallback], [progressCallback]);
Alias of when to maintain naming consistency with ES6.
Param | Type | Details |
---|---|---|
value | * |
Value or a promise |
successCallback
(optional)
|
Function= | |
errorCallback
(optional)
|
Function= | |
progressCallback
(optional)
|
Function= |
Promise | Returns a promise of the passed value or promise |
Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.
Param | Type | Details |
---|---|---|
promises | Array.<Promise>Object.<Promise> |
An array or hash of promises. |
Promise | Returns a single promise that will be resolved with an array/hash of values,
each value corresponding to the promise at the same index/key in the |