Promise 简单实现

/**
 * Created by wikid on 3/6/17.
 */
;(function (f) {
    /**
     * 模块 引入方式
     */
    if (typeof exports === 'object') module.exports = f();
    else if (typeof define === 'function' && define.amd) define(f);
    else if (typeof window !== undefined) window.Promise = f();
})(function () {
    function Promise(fn) {
        /*
            value: resolve 的结果值(主要要来传递)
            state: promise 的状态
                    1. pending  等待中
                    2. fulfilled 已完成
                    3. rejected 失败
            deferred: resolve 的回调栈
         */
        var value = null,
            state = 'pending',
            deferreds = [];

        /**
         * 为了兼容 promise 的串行，所以同一 then 方法同一返回 Promise 类型的实例
         * @param fulfilledCall
         * @param rejectedCall
         * @returns {Promise}
         */
        this.then = function (fulfilledCall, rejectedCall) {
            /**
             *  每一次调用 then 方法时，都会创建一个 bridge promise
             */
            return new Promise(function (resolve) {
                handle({
                    fulfilledCall: fulfilledCall || null,
                    rejectedCall: rejectedCall || null,
                    resolve: resolve,
                    reject: reject
                })
            });
        };

        function handle(deferred) {
            if (state === 'pending') {
                deferreds.push(deferred);
                return;
            }

            var cb = state === 'fulfilled' ? deferred.fulfilledCall : deferred.rejectedCall,
                ret;
            // 兼容异常处理
            if (cb === null) {
                cb = state === 'fulfilled' ? deferred.resolve : deferred.reject;
                cb(value);
                return
            }

            try {
                ret = cb(value);
                deferred.resolve(ret);
            } catch (e) {
                deferred.resolve(e);
            }
        }

        function resolve(newValue) {
            //
            if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
                var then = newValue.then;
                if (typeof then === 'function') {
                    then.call(newValue, resolve, reject);
                    return;
                }
            }

            state = 'fulfilled';
            value = newValue;
            finale();
        }

        function reject(reason) {
            state = 'rejected';
            value = reason;
            finale();
        }

        function finale() {
            /**
             * 异步执行，主要是兼容，创建 promise 实例时，fn 内直接将 promise 的状态置为 fulfilled，
             * 而 后面的 then 方法还未执行，从而导致 deferreds 为 空数组
             */
            setTimeout(function () {
                deferreds.forEach(function (deferred, i) {
                    deferred(value);
                });
            }, 0)
        }

        fn(resolve);
    }

    return Promise;
});