CODEWITHSUNDEEP
javascriptcross-browserpromisees6-promise
just-boris
just-boris

Reputation: 9746

Promise.defer() browser support

I am looking for a way to create deferred object which will be resolved outside the current scope. I like deferred objects and as I see Promise.defer() in Chrome 38 returns the deferred object.

But in latest Firefox 34 Promise.defer is undefined as well in Safari 8.0.

So I can't use Promise.defer everywhere now. What about future status? Will it be implemented in other browsers or will be removed as deprecated?

Upvotes: 23

Views: 27673

Answers (4)

ashish
ashish

Reputation: 878

This is now natively supported on the Web.

let { promise, resolve, reject } = Promise.withResolvers();

MDN API Reference

Upvotes: -1

GregTCLTK
GregTCLTK

Reputation: 51

Promise.withResolvers() has been added to the spec. See this MDM article

It can be used like this:

async function* readableToAsyncIterable(stream) {
  let { promise, resolve, reject } = Promise.withResolvers();
  stream.on("error", (error) => reject(error));
  stream.on("end", () => resolve());
  stream.on("readable", () => resolve());

  while (stream.readable) {
    await promise;
    let chunk;
    while ((chunk = stream.read())) {
      yield chunk;
    }
    ({ promise, resolve, reject } = Promise.withResolvers());
  }
}

Upvotes: 4

Alexander O'Mara
Alexander O'Mara

Reputation: 60527

According to the MDN article on Deferred, the .defer method is obsolete. If you look at this bug issue, it says that Promise.defer is non-standard, so it's not likely to return.

Starting from Gecko 30, this object is obsolete and should not be used anymore. Use the new Promise() constructor instead.

They offer an example of how to rewrite Promise.defer code, to instead use new Promise.

Promise.defer

var deferred = Promise.defer();
doSomething(function cb(good) {
    if (good)
        deferred.resolve();
    else
        deferred.reject();
});
return deferred.promise;

new Promise

return new Promise(function(resolve, reject) {
    doSomething(function cb(good) {
        if (good)
            resolve();
        else
            reject();
    });
});

There are several advantages to the new format, including cleaner code, and improved throw safety (if the code in the promise init function throws synchronously the promise will reject).

Upvotes: 27

dfsq
dfsq

Reputation: 193261

Although I doubt this is a good idea, but technically you can implement custom deferred object based on Promises. For example:

function defer() {
    var deferred = {};
    var promise = new Promise(function(resolve, reject) {
        deferred.resolve = resolve;
        deferred.reject  = reject;
    });
    deferred.promise = promise;
    return deferred;
}

var deferred = defer();

deferred.promise.then(function(data) {
    document.body.innerHTML += '<p>Resolved: ' + data + '</p>';
});

document.body.innerHTML = '<p>Deferred created.</p>';

setTimeout(function() {
    deferred.resolve(123);
}, 2000);

Upvotes: 36

Related Questions