Returning angular promise from a function that resolves the promise very quickly

Question

I am writing an asynchronous javascript function that will be called by consumers to get certain data. Following is the simple implementation that I wrote initially (error handing and other stuff removed for clarity).

function getData(callback){
    if (data is available as a JavaScript object){
        callback(data);
    }else{
        getAsyncData(function(data){
             //some transformations on data
             callback(data); 
        });
    }
}

What is important to note is that getData can return data quickly if data is already available as a JavaScript object.

I want to replace this implementation with the one that returns a promise object to the caller. This fiddle shows sample implementation - http://fiddle.jshell.net/ZjUg3/44/

The question - Since getData can return quickly, can there be a possiblity where getData is resolving the promise even before caller has established handler chain using then method? Just to simulate this, in the fiddle if i call then method inside setTimeout function (with zero delay), callback doesn't get called. If i call the then method outside of the setTimeout function, callback gets called. I am not sure if this is even a valid concern or valid usecase. I am quite new to angularjs development and would appreciate your views :)

Answer 1

If you want getData() to return a $q promise instead of using a callback, I'd do the following refactor using $q.when() and usual $q.resolve() :

function getData()
{
    if (data is available as a JavaScript object) {
        return $q.when(data); // resolves immediately
    } else {
        var q = $q.defer();
        getAsyncData(function(data){
             //some transformations on data
             q.resolve(data); 
        });
        return q.promise;
    }
}

Answer 2

No, a significant and important part of being a promise is that it doesn't matter when you attach the handler. Even if you create a promise now and resolve it immediately, then keep your computer running for the next 50 years, then attach a handler it will still fire.

All of this does assume that there isn't a bug/corner case in angularjs's promise implementation. If it doesn't work, it's a bug though.

If you ever need to know anything about how promises work, you can always refer to the Promises/A+ spec which angular adheers to. As a spec, it's one of the simplest and easiest to understand that I've come across (although I should mention that I've been involved in the spec for quite a while now).