JavaScript native Promise() without callback

Question

Look at this jQuery code:

var promise = new Deferred(),
    some;

some = function(promise) {
    // do cool things

    promise.resolve();
};

promise.then(/*  callback cool things   */);

// init everything
some(promise);

I am not sure about architecture correctness of such approach, but I used it for long time and it is convenient for me.

In native JavaScript I can not use such approach. Constructor new Promise() requires a callback parameter, so I can not pass instance of Promise as a parameter.

So my question is: how can I predefine JavaScript native promise, pass it as a parameter to function and the resolve?

@user2864740 I know it's an old comment, but is that a joke? — Evan Davis, Nov 23 '15 at 14:59
@Mathletics Not at all. It was a serious comment illustrating an invalid (and recently fixed) spelling, with the goal of initiating a correction from the original author. — user2864740, Nov 23 '15 at 17:12

score 2 · Accepted Answer · answered May 10 '14 at 21:29

The execution flow would be a little different, but basically work the same way:

function some(resolve, reject) {
    resolve();
}

var promise = new Promise(some);

promise.then(/*  callback cool things   */);

Instead of some getting passed the promise itself, it gets passed the resolve and reject functions. So, the dependency is just the other way round.

vzwick · Answer 2 · 2014-07-24T13:41:18.097

0

Here's a basic implementation that would preserve your application flow as-is.

Do not use this in real life - you'd be missing out on throw safety (thanks to @BenjaminGruenbaum for the hint).

var MyDeferred = function() {
    var _resolve,
        _reject,
        capturedPromise = new Promise(function(resolve, reject){
            _resolve = resolve;
            _reject  = reject;
        });

    return {
        'resolve' : _resolve,
        'reject'  : _reject,
        'then'    : function() { capturedPromise.then.apply(capturedPromise, arguments); },
        'catch'   : function() { capturedPromise.catch.apply(capturedPromise, arguments); }
    }
};

edited Jul 24 '14 at 13:41

answered May 10 '14 at 21:47

vzwick

11,008
5
43
63

@Felix answer is more acceptable for me, but anyway thank you for your realization – Boris Zagoruiko May 10 '14 at 21:59
Please do not actually do this. There is a reason Deferred objects are bad and the promise constructor is better (throw safety). – Benjamin Gruenbaum May 10 '14 at 22:28

JavaScript native Promise() without callback

2 Answers2

Linked