如何从图书馆创建承诺

Question

I am confused on this one because every tutorial I have found so far assumes I can edit the library code, or that the library only has call backs or the call back as the last parameter.

The library I am using has every function set up like function(successCallBack(result), FailCallBack(error),options)

So in each instance, I end up using code like

var options={stuff1:1, stuff2:2};

doStuff(success,failure,options);

function success(result){
    //handle, usually with another call to a similar function, chaining callbacks together
};

function failure(error){
     //handle error
};

How do I convert these into promises when I only have control of the call, and the success and failures?

Also, as a bonus, the chains are accessing variables outside them.

var options={stuff1:1, stuff2:2};

doStuff(success,failure,options);

function success(result){
    var options2={stuff1:1, stuff2:2};
    doStuff2(function(result2){
                processStuff(result1, result2);
            },function(error){
                 //handle error
            },options2)
};

function failure(error){
     //handle error
};

function processSuff(result1,result2){
    //do things to results
}

Thanks

Answer 1

You could use the following function. It accepts a function to promisify and options, and returns promise:

let promisify = (fn, opts) => {
  return new Promise((resolve, reject) => {
    fn(resolve, reject, opts);
  });
}

It could be used as follows:

promisify(doStuff, options)
  .then(data => console.log('Success call', data))
  .catch(err => console.log('Error', err));

Answer 2

Rather than call promisify every time you want to use your function, you can wrap it once and get a new function that you can just use as needed. The new function will return a promise and resolve/reject instead of the success and fail callbacks. This particular version of promisify is specifically coded for the calling convention you show of fn(successCallback, errorCallback, options) . If you have other functions with different calling conventions, then you can create a different promisify version for them:

// return a promisified function replacement for this specific
//    calling convention: fn(successCallback, errorCallback, options)
function promisify1(fn) {
    return function(options) {
        return new Promise((resolve, reject) => {
            fn(resolve, reject, options);
        });
    }
}

So, then you would use this like this:

// do this once, somewhere near where doStuff is imported
let doStuffPromise = promisify1(doStuff);

// then, anytime you would normally use doStuff(), you can just use
//    doStuffPromise() instead

doStuffPromise(options).then(results => {
    // process results here
}).catch(err => {
    // handle error here
});

The advantage of doing it this way is that you can "promisify" a given function of set of functions just once in your project and then just use the new promisified versions.

---

Suppose you imported an object that had a whole bunch of these types of interfaces on it. You could then make yourself a promisifyObj() function that would make a promisified interface for all the functions on the object.

// a "Promise" version of every method on this object
function promisifyAll(obj) {
    let props = Object.keys(obj);
    props.forEach(propName => {
        // only do this for properties that are functions
        let fn = obj[propName];
        if (typeof fn === "function") {
            obj[propName + "Promise"] = promisify1(fn);
        }
    });
}

So, if you had an object named myModule that had all these methods with this non-promise interface on it, you could promisify that module in one step:

promisifyAll(myModule);

And, then you could use any method from that object by just adding the "Promise" suffix to the method name:

myModule.someMethodPromise(options).then(results => {
    // process results here
}).catch(err => {
    // handle error here
});