Deferred/promise confusion and implementation

Question

If I would like to implement deferred by myself, would it be a right way to do(trying to understand the internal logic):

Does deferred counts as a behavioural pattern?

What is the difference between deferred and promise?

function Deferred() {
    var d = {},
        f = {},
        a = {}, 
        state = 'pending';

    return {
        resolve: function(){
            state = 'resolved';
            a.fn.apply(a.context, arguments);
            d.fn.apply(d.context, arguments);
        },

        reject:  function(){
            state = 'rejected';
            a.fn.apply(a.context, arguments);
            f.fn.apply(f.context, arguments);
        },

        done: function(fn, context) {
            d = {fn: fn, context: context};
            return this;
        },

        fail: function(fn, context) {
            f = {fn:fn, context: context};
            return this;
        },

        always: function(fn, context) {
            a = {fn:fn, context: context};
            return this;
        },

        state: state
    }
}

Application example:

var obj = Deferred();
    obj.done(function(arg){
        console.log('we are done here. why? -', arg);
    }, window)
     .always(function(arg){
        console.log('print that in any case. and some details:', arg);
    }, window)
     .fail(function(arg){
        console.log('we failed here. why? -', arg);
    }), window;


    obj.reject('some arguments');
    obj.resolve({argument: 'hooray!'});

Check this question http://stackoverflow.com/questions/6801283/what-are-the-differences-between-deferred-promise-and-future-in-javascript — elclanrs, Jul 27 '14 at 07:36

score 2 · Accepted Answer · edited May 23 '17 at 12:27

If I would like to implement deferred by myself, would this be a right way to do?

No, your code misses a few important points:

A promise/deferred represents one single outcome only. It's state must not be changed after it is settled (fulfilled or rejected).
No matter when a callback is installed, it will be executed as soon as possible with the result. Your code fails to do that when the result has already arrived.
No matter how many callbacks are installed, they all will be executed. Your code allows to store only a single callback.

You might want to have a look at this example implementation or How is a promise/defer library implemented?.

Also, for a promise you will want to implement an interoperable then method for chaining, whose behaviour is described in the Promises/A+ specification.

Does deferred counts as a behavioural pattern?

Yeah, you could count them as a mix of observer or visitor pattern.

What is the difference between deferred and promise?

In general, a deferred does provide the methods to fulfill or reject, while a promise is the interface to install the callbacks on (without the ability to resolve the promise). See What are the differences between Deferred, Promise and Future in JavaScript? for details.

You answered all my questions. Thanks! – Nik Terentyev Jul 28 '14 at 10:19 — Nik Terentyev, Jul 28 '14 at 10:19

Deferred/promise confusion and implementation

1 Answers1

Linked