promise/回调混合函数

Question

我在玩弄promise和回调，想知道如果没有回调被传递，写一个返回promise的函数的正确方法是什么。

我的结果看起来是这样的，但我不确定这是否正确（反模式的意思）

const mySuperFunction = function mySuperFunction(data, cb) {

    let wrapper = new Promise((resolve, reject) => {
        setTimeout(() => {

            if (Math.random() >= 0.5) {
                resolve(Date.now());
            } else {
                reject(new Error("Not today..."));
            }

        }, 100);
    });


    if (cb) {

        wrapper.then((result) => {
            cb(null, result);
        }, (error) => {
            cb(error);
        });

    } else {
        return wrapper;
    }

};


mySuperFunction().then((time) => {
    console.log(time)
}).catch((err) => {
    console.log(err);
});


mySuperFunction(null, (err, time) => {
    console.log(err, time)
});

它很简单：创建一个函数，并将“工作”代码包装在一个promise中。如果没有回调传递给我的函数，我返回包装的promise。如果一个回调被传递，我从包装/调用它。然后（...）和。抓住（...）

这样可以吗，还是我错过了一些不起作用的特殊情况？

Answer 1

这样可以吗，还是我错过了一些不起作用的特殊情况？

您的代码可以工作，但它增加了无用的开销。promise比回调消耗更多的内存，并且比回调慢。

我会写这样的东西

const { promisify } = require('util')

function mySuperFunctionCallback (data, cb) {
  setTimeout(() => {
    if (Math.random() >= 0.5) {
      cb(Date.now())
    } else {
      cb(new Error('Not today...'))
    }
  }, 100)
}

const mySuperFunctionAsync = promisify(mySuperFunctionCallback)

function mySuperFunction (data, cb) {
  if (cb) {
    mySuperFunctionCallback(data, cb)
  } else {
    return mySuperFunctionAsync(data)
  }
}

mySuperFunction().then((time) => {
  console.log(time)
}).catch((err) => {
  console.log(err)
})

mySuperFunction(null, (err, time) => {
  console.log(err, time)
})