This example expands on the Wrapping async transactions with promises example to illustrate how to create your own Promise subclass for performing operations on arrays.
You can subclass a YUI promise with Y.extend the same way you would any other class. Keep in mind that Promise constructors take a function as a parameter so you need to call the superclass constructor in order for it to work.
``` function ArrayPromise() { ArrayPromise.superclass.constructor.apply(this, arguments); } Y.extend(ArrayPromise, Y.Promise); ```Chaining promise methods is done by returning the result of calling the promise's `then()` method. `then()` always returns a promise of its same kind, so this will allow us to chain array operations as if they were real arrays.
For the purpose of this example we will only add the `each`, `filter` and `map` methods from the `array-extras` module.
``` {{>subclass-array-methods}} ```Finally we need a simple way to take a promise that we know contains an array and create an ArrayPromise with its value.
``` {{>subclass-toarray-fn}} ```There are many cases in which you would want to work on asynchronous array values. Performing more than one async operation at a time and dealing with the result is one common use case. `Y.Promise.all` waits for many operations and returns a promise representing an array with the result of all the operations, so you could wrap it in an ArrayPromise to modify all those results.
We will use the JSONP Cache from the previous example and make several simultaneous requests.
``` {{>subclass-array-operations}} ```