Nodejs的Promise库

今天研究了下nodejs的Promise库，发现学到了不少，他的源代码不多，但是很精辟，我加了点注释，可能比不加还难懂。。。凑活着看吧。。

 

库：https://npmjs.org/package/promise

Promise/A+规范：http://promises-aplus.github.io/promises-spec/

 

core.js

 

[javascript] view plaincopyprint?
  1. 'use strict'  
  2.   
  3. var nextTick = require('./lib/next-tick')  
  4.   
  5. module.exports = Promise  
  6. function Promise(fn) {  
  7.   
  8.     // 如果不是一个Promise对象，那么调用构造函数包装下  
  9.     if (!(this instanceof Promise)) return new Promise(fn)  
  10.   
  11.     // 参数必须是一个函数  
  12.     if (typeof fn !== 'function') throw new TypeError('not a function')  
  13.   
  14.     var state = null  
  15.     var delegating = false  
  16.     var value = null  
  17.     var deferreds = []  
  18.     var self = this  
  19.   
  20.     // 成员函数：then。返回Promise2  
  21.     this.then = function (onFulfilled, onRejected) {  
  22.         // 返回一个新的Promise，Promise2。  
  23.         return new Promise(function (resolve, reject) {  
  24.             // Handler没特别的，就是为了保存4个参数  
  25.             handle(new Handler(onFulfilled, onRejected, resolve, reject))  
  26.         })  
  27.     }  
  28.   
  29.     // 处理defer，fulfill, reject等问题  
  30.     //  
  31.     function handle(deferred) {  
  32.         // 还在pending？那么走人  
  33.         if (state === null) {  
  34.             deferreds.push(deferred)  
  35.             return  
  36.         }  
  37.         // 状态已变：  
  38.         nextTick(function () {  
  39.             // 根据state来决定是调用fulfill还是reject  
  40.             var cb = state ? deferred.onFulfilled : deferred.onRejected  
  41.             if (cb === null) {  
  42.                 // 假如没有提供对应的callback，那么调用“默认”的回调  
  43.                 (state ? deferred.resolve : deferred.reject)(value)  
  44.                 return  
  45.             }  
  46.   
  47.             // 调用对应的回调  
  48.             var ret  
  49.             try {  
  50.                 ret = cb(value)  
  51.             }  
  52.             catch (e) {  
  53.                 // 出现异常了，那么把状态改成reject  
  54.                 deferred.reject(e)  
  55.                 return  
  56.             }  
  57.   
  58.             // 回调运行没问题，那么就把回调的返回值作为自己的值，状态变成fulfilled  
  59.             deferred.resolve(ret)  
  60.         })  
  61.     }  
  62.   
  63.     // 作为第一个参数传给你写的那个函数  
  64.     //  
  65.     function resolve(newValue) {  
  66.         // 这里有点没搞懂，为啥要针对delegating flag来return，  
  67.         // 其实假如delegating标记已设置，这个函数就再也进不来了呀。  
  68.         // 难道仅仅为了防止出错？  
  69.         if (delegating)  
  70.             return  
  71.         resolve_(newValue)  
  72.     }  
  73.   
  74.     function resolve_(newValue) {  
  75.         // 说明已经被处理过了！不用再处理了，其实如果会被调用两次，应该是出错了!  
  76.         if (state !== null)  
  77.             return  
  78.         try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure  
  79.             if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.')  
  80.   
  81.             // resolve的返回值可以是普通值，也可以是一个promise，针对promise要特殊处理下  
  82.             if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {  
  83.   
  84.                 // 判别他是不是一个promise  
  85.                 var then = newValue.then  
  86.                 if (typeof then === 'function') {  
  87.   
  88.                     // 是的。。那就有点麻烦，设个标记先  
  89.                     delegating = true  
  90.                     // 根据 Promise/A+，当前promise的状态保持pending，且依赖于返回的promise的状态，即newValue  
  91.                     // 所以调用 newValue.then。  
  92.                     then.call(newValue, resolve_, reject_)  
  93.                     return  
  94.                 }  
  95.             }  
  96.   
  97.             // 普通值，简单了  
  98.             state = true  
  99.             value = newValue  
  100.             // 触发依赖于这个promise的所有回调（通过then设置上去的）  
  101.             finale()  
  102.         } catch (e) { reject_(e) }  
  103.     }  
  104.   
  105.     // 作为第二个参数传给你写的那个函数  
  106.     //  
  107.     function reject(newValue) {  
  108.         if (delegating)  
  109.             return  
  110.         reject_(newValue)  
  111.     }  
  112.   
  113.     function reject_(newValue) {  
  114.         if (state !== null)  
  115.             return  
  116.         state = false  
  117.         value = newValue  
  118.         finale()  
  119.     }  
  120.   
  121.     // 触发依赖于这个promise的所有回调（通过then设置上去的）  
  122.     function finale() {  
  123.         for (var i = 0, len = deferreds.length; i < len; i++)  
  124.             handle(deferreds[i])  
  125.         deferreds = null  
  126.     }  
  127.   
  128.     // 创建完，马上就调用，真直接  
  129.     //  
  130.     try { fn(resolve, reject) }  
  131.     catch (e) { reject(e) }  
  132. }  
  133.   
  134.   
  135. function Handler(onFulfilled, onRejected, resolve, reject) {  
  136.     this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null  
  137.     this.onRejected = typeof onRejected === 'function' ? onRejected : null  
  138.     this.resolve = resolve  
  139.     this.reject = reject  
  140. }  
'use strict'

var nextTick = require('./lib/next-tick')

module.exports = Promise
function Promise(fn) {

    // 如果不是一个Promise对象，那么调用构造函数包装下
    if (!(this instanceof Promise)) return new Promise(fn)

    // 参数必须是一个函数
    if (typeof fn !== 'function') throw new TypeError('not a function')

    var state = null
    var delegating = false
    var value = null
    var deferreds = []
    var self = this

    // 成员函数：then。返回Promise2
    this.then = function (onFulfilled, onRejected) {
        // 返回一个新的Promise，Promise2。
        return new Promise(function (resolve, reject) {
            // Handler没特别的，就是为了保存4个参数
            handle(new Handler(onFulfilled, onRejected, resolve, reject))
        })
    }

    // 处理defer，fulfill, reject等问题
    //
    function handle(deferred) {
        // 还在pending？那么走人
        if (state === null) {
            deferreds.push(deferred)
            return
        }
        // 状态已变：
        nextTick(function () {
            // 根据state来决定是调用fulfill还是reject
            var cb = state ? deferred.onFulfilled : deferred.onRejected
            if (cb === null) {
                // 假如没有提供对应的callback，那么调用“默认”的回调
                (state ? deferred.resolve : deferred.reject)(value)
                return
            }

            // 调用对应的回调
            var ret
            try {
                ret = cb(value)
            }
            catch (e) {
                // 出现异常了，那么把状态改成reject
                deferred.reject(e)
                return
            }

            // 回调运行没问题，那么就把回调的返回值作为自己的值，状态变成fulfilled
            deferred.resolve(ret)
        })
    }

    // 作为第一个参数传给你写的那个函数
    //
    function resolve(newValue) {
        // 这里有点没搞懂，为啥要针对delegating flag来return，
        // 其实假如delegating标记已设置，这个函数就再也进不来了呀。
        // 难道仅仅为了防止出错？
        if (delegating)
            return
        resolve_(newValue)
    }

    function resolve_(newValue) {
        // 说明已经被处理过了！不用再处理了，其实如果会被调用两次，应该是出错了!
        if (state !== null)
            return
        try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
            if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.')

            // resolve的返回值可以是普通值，也可以是一个promise，针对promise要特殊处理下
            if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {

                // 判别他是不是一个promise
                var then = newValue.then
                if (typeof then === 'function') {

                    // 是的。。那就有点麻烦，设个标记先
                    delegating = true
                    // 根据 Promise/A+，当前promise的状态保持pending，且依赖于返回的promise的状态，即newValue
                    // 所以调用 newValue.then。
                    then.call(newValue, resolve_, reject_)
                    return
                }
            }

            // 普通值，简单了
            state = true
            value = newValue
            // 触发依赖于这个promise的所有回调（通过then设置上去的）
            finale()
        } catch (e) { reject_(e) }
    }

    // 作为第二个参数传给你写的那个函数
    //
    function reject(newValue) {
        if (delegating)
            return
        reject_(newValue)
    }

    function reject_(newValue) {
        if (state !== null)
            return
        state = false
        value = newValue
        finale()
    }

    // 触发依赖于这个promise的所有回调（通过then设置上去的）
    function finale() {
        for (var i = 0, len = deferreds.length; i < len; i++)
            handle(deferreds[i])
        deferreds = null
    }

    // 创建完，马上就调用，真直接
    //
    try { fn(resolve, reject) }
    catch (e) { reject(e) }
}


function Handler(onFulfilled, onRejected, resolve, reject) {
    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null
    this.onRejected = typeof onRejected === 'function' ? onRejected : null
    this.resolve = resolve
    this.reject = reject
}

index.js

[javascript] view plaincopyprint?
  1. 'use strict'  
  2.   
  3. //This file contains then/promise specific extensions to the core promise API  
  4.   
  5. var Promise = require('./core.js')  
  6. var nextTick = require('./lib/next-tick')  
  7.   
  8. module.exports = Promise  
  9.   
  10.   
  11. // 静态函数，为了将一个普通值变成promise，或者把类promise（即有then成员函数的对象）变成promise  
  12. //  
  13. Promise.from = function (value) {  
  14.     if (value instanceof Promise) return value  
  15.     return new Promise(function (resolve) { resolve(value) })  
  16. }  
  17.   
  18. // 静态函数，去NodeJs化，把nodeJs风格的callback，变成能够返回Promise的函数。  
  19. //  
  20. Promise.denodeify = function (fn) {  
  21.     // 返回的是一个包装过的函数  
  22.     return function () {  
  23.         var self = this  
  24.         var args = Array.prototype.slice.call(arguments)  
  25.         // 就是返回了一个promise，不过自己写了resolver函数  
  26.         return new Promise(function (resolve, reject) {  
  27.             // 很简单，就参数最后，加一个callback  
  28.             args.push(function (err, res) {  
  29.                 if (err) reject(err)  
  30.                 else resolve(res)  
  31.             })  
  32.             fn.apply(self, args)  
  33.         })  
  34.     }  
  35. }  
  36.   
  37. // 静态函数，NodeJs化，把返回promise的函数变成nodeJs风格的callback。  
  38. //  
  39. Promise.nodeify = function (fn) {  
  40.     // 返回的是一个包装过的函数  
  41.     return function () {  
  42.         var args = Array.prototype.slice.call(arguments)  
  43.   
  44.         // 如果原函数最后参数是callback，就取出来  
  45.         var callback = typeof args[args.length - 1] === 'function' ? args.pop() : null  
  46.         try {  
  47.             // 执行promise本身，但是通过成员函数nodeify挂了1个then的回调上去。  
  48.             return fn.apply(this, arguments).nodeify(callback)  
  49.         } catch (ex) {  
  50.             if (callback == null) {  
  51.                 // 有异常了，  
  52.                 return new Promise(function (resolve, reject) { reject(ex) })  
  53.             } else {  
  54.                 nextTick(function () {  
  55.                     callback(ex)  
  56.                 })  
  57.             }  
  58.         }  
  59.     }  
  60. }  
  61.   
  62. // 静态函数  
  63. //  
  64. Promise.all = function () {  
  65.     var args = Array.prototype.slice.call(arguments.length === 1 && Array.isArray(arguments[0]) ? arguments[0] : arguments)  
  66.     // 返回一个新的Promise  
  67.     return new Promise(function (resolve, reject) {  
  68.         if (args.length === 0) return resolve([])  
  69.         var remaining = args.length  
  70.         function res(i, val) {  
  71.             try {  
  72.   
  73.                 // 判断是不是一个promise  
  74.                 if (val && (typeof val === 'object' || typeof val === 'function')) {  
  75.                     var then = val.then  
  76.                     // 是的话，麻烦，要等一下他  
  77.                     if (typeof then === 'function') {  
  78.                         // 回调res函数（就是自身）  
  79.                         then.call(val, function (val) { res(i, val) }, reject)  
  80.                         return  
  81.                     }  
  82.                 }  
  83.   
  84.                 // 不是，那么简单，保存它的值  
  85.                 args[i] = val  
  86.   
  87.                 // 等到所有的值都取到了，就可以返回了  
  88.                 if (--remaining === 0) {  
  89.                     resolve(args);  
  90.                 }  
  91.             } catch (ex) {  
  92.                 reject(ex)  
  93.             }  
  94.         }  
  95.         for (var i = 0; i < args.length; i++) {  
  96.             res(i, args[i])  
  97.         }  
  98.     })  
  99. }  
  100.   
  101.   
  102.   
  103. // 成员函数： 加入了抛异常功能，但是也不会返回promise了。  
  104. //  
  105. Promise.prototype.done = function (onFulfilled, onRejected) {  
  106.   
  107.     // 先执行then，然后附加一个then，这里做了优化，没有参数就直接附加then。  
  108.     var self = arguments.length ? this.then.apply(this, arguments) : this  
  109.   
  110.     self.then(null, function (err) {  
  111.         nextTick(function () {  
  112.             throw err  
  113.         })  
  114.     })  
  115. }  
  116.   
  117. // 成员函数： nodeJs话，其实实现的很简单。  
  118. //  
  119. Promise.prototype.nodeify = function (callback) {  
  120.     if (callback == null) return this  
  121.   
  122.     this.then(function (value) {  
  123.         nextTick(function () {  
  124.             callback(null, value)  
  125.         })  
  126.     }, function (err) {  
  127.         nextTick(function () {  
  128.             callback(err)  
  129.         })  
  130.     })  
  131. } 
posted @ 2014-10-29 10:34  x_window  阅读(311)  评论(0)    收藏  举报