promisify 的过程

bluebird 中的promisify的原型源码是

Promise.promisify = function (fn, options) {
    if (typeof fn !== "function") {
        throw new TypeError("expecting a function but got " + util.classString(fn));
    }
    if (isPromisified(fn)) {
        return fn;
    }
    options = Object(options);
    var receiver = options.context === undefined ? THIS : options.context;
    var multiArgs = !!options.multiArgs;
    var ret = promisify(fn, receiver, multiArgs);
    util.copyDescriptors(fn, ret, propsFilter);
    return ret;
};
复制代码

可以看到在判断了是否是函数的同时判断了fn是否已经被promise化过。 这里的参数以(fn,undefined)为例，调用的promisify函数传入的参数是(fn,{},false)

function promisify(callback, receiver, multiArgs) {
    return makeNodePromisified(callback, receiver, undefined,
                                callback, null, multiArgs);
}
复制代码

promisify 实际是包装 了makeNodePromisified 这个函数,对参数进行了传递

var makeNodePromisified = canEvaluate
        ? makeNodePromisifiedEval
        : makeNodePromisifiedClosure;
复制代码

makeNodePromisified 这个函数通过 canEvaluate 这个变量进行了调用函数的判断，这是一个判断运行环境是否是浏览器的变量。这里我们调用的是 makeNodePromisifiedClosure 这个函数

function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {
    var defaultThis = (function() {return this;})();
    var method = callback;
    if (typeof method === "string") {
        callback = fn;
    }
    function promisified() {
        var _receiver = receiver;
        if (receiver === THIS) _receiver = this;
        var promise = new Promise(INTERNAL);
        promise._captureStackTrace();
        var cb = typeof method === "string" && this !== defaultThis
            ? this[method] : callback;
        var fn = nodebackForPromise(promise, multiArgs);//变成promise
        try {
            cb.apply(_receiver, withAppended(arguments, fn));//调用传入的cb
        } catch(e) {
            promise._rejectCallback(maybeWrapAsError(e), true, true);
        }
        if (!promise._isFateSealed()) promise._setAsyncGuaranteed();
        return promise;
    }
    util.notEnumerableProp(promisified, "__isPromisified__", true);
    return promisified;
}
复制代码

这里先把_receiver绑定在this上，调用nodebackForPromise返回一个promise赋给fn, nodebackForPromise的源码是

function nodebackForPromise(promise, multiArgs) {
    return function(err, value) {
        if (promise === null) return;
        if (err) {
            var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
            promise._attachExtraTrace(wrapped);
            promise._reject(wrapped);
        } else if (!multiArgs) {
            promise._fulfill(value);
        } else {
            var $_len = arguments.length;var args = new Array(Math.max($_len - 1, 0)); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];};
            promise._fulfill(args);
        }
        promise = null;
    };
}
复制代码

可以看到这里没有错误就调用 promise._fulfill(value) ,如果抛出了错误就调用 promise._reject处理 ,上面 cb.apply(_receiver, withAppended(arguments, fn)) 实际上可以看做 cb.apply(this,arguments,fn) 这里的fn即为 nodebackForPromise 返回的promise，funtion(err,value)这种形式也非常有node异步函数的特征。因此函数的的执行是在调用异步函数cb完成后调用回调函数fn这样就进入了promise中。即将异步函数promise化了。