如何使功能与等待同时还可以进行回调？

Question

I want to create a function that can work with both async/await and usual callback pattern. so something like the following would work:

function myFunc(cb) {
   setTimeout(function(){   //something async
       console.log('hello');
       cb();
   });
}

myFunc(function(){
   console.log('world');
});

but what is below won't work

function myFunc(cb = function(){}) {
   setTimeout(function(){   //something async
       console.log('hello');
       cb();
   }, 1000);
}

(async ()=> {
     await myFunc();
     console.log('world');
})();

I understand for await to work myFunc needs to return a promise and even though i've few ideas in mind on how to take callback and return promise, I'd like to see some proper way to do this.

Answer 1

You can use both like this

function myFunc (giveback, callback) {
    return new Promise((resolve, reject) => {
        setTimeout(function() {
           resolve(giveback);
           if (typeof callback === 'function') callback(null, giveback);
        }, 1000)
    }
}

Answer 2

Typically, the way to achieve this is to check the amount of arguments explicitly passed, and act accordingly.

If you want myFunc() to achieve both styles simultaneously, here's a possible implementation:

 function myFunc(cb) { // some async logic const p = new Promise((resolve, reject) => { setTimeout(() => { // pass some value here resolve('success') }, 1000) setTimeout(() => { // pass some error here reject(new Error('something broke')) }, Math.random() * 2000) // 50% chance of failure }) if (arguments.length < 1) { // invoked promise-style return p } else if (typeof cb === 'function') { // invoked callback-style with valid function p.then(result => { cb(null, result) }, error => { cb(error) }) } else { // invoking in callback-style with a non-function // should produce a fatal error throw new TypeError('cb is not a function') } } // usage try { // invalid invocation without function parameter myFunc('strings do not implement [[Call]]') } catch (error) { console.log(error.message) } // callback-style myFunc((error, value) => { if (error) return console.log(`callback with error: ${error.message}`) console.log(`callback with value: ${value}`) }) // promise-style myFunc().then(value => { console.log(`promise with value: ${value}`) }, error => { console.log(`promise with error: ${error.message}`) }) 

The above implementation intentionally does not return a promise when invoked with a callback. If you want it to do so, then I recommend this approach, as it's a little more flexible (ie if you want to pass a callback and still treat it as a then-able):

 function myFunc(cb = () => {}) { if (arguments.length > 0 && typeof cb !== 'function') { // invoking in callback-style with a non-function // should produce a fatal error throw new TypeError('cb is not a function') } // some async logic return new Promise((resolve, reject) => { setTimeout(() => { // pass some value here resolve('success') }, 1000) setTimeout(() => { // pass some error here reject(new Error('something broke')) }, Math.random() * 2000) // 50% chance of failure }).then(result => { cb(null, result) // propagate result return result }, error => { cb(error) // propagate error throw error }) } // usage try { // invalid invocation without function parameter myFunc('strings do not implement [[Call]]') } catch (error) { console.log(error.message) } // callback-style myFunc((error, value) => { if (error) return console.log(`callback with error: ${error.message}`) console.log(`callback with value: ${value}`) }) // promise-style myFunc().then(value => { console.log(`promise with value: ${value}`) }, error => { console.log(`promise with error: ${error.message}`) }) // using both styles myFunc((error, value) => { if (error) return console.log(`mixed callback with error: ${error.message}`) console.log(`mixed callback with value: ${value}`) }).then(value => { console.log(`mixed promise with value: ${value}`) }, error => { console.log(`mixed promise with error: ${error.message}`) }) 

Answer 3

Here is a functional example of what I described earlier:

const myFunc = (obj, callback) => {
    if (!callback) {
        const performWork = async () => obj
        return new Promise(async (resolve, reject) => {
            const value = await performWork()
            resolve(value)
        })
    }
    const cb = obj
    callback(cb)
}

const test = { test: 1337 }

// Promise version
myFunc(test)
    .then((res) => console.log('Promise version', res))

// Callback version
myFunc(test, (res) => {
    console.log('Callback version', res)
})