Promise 原理

var Promise = (function() {
    function Promise(resolver) {
        // resolver必须是函数
        if (typeof resolver !== 'function') { 
            throw new TypeError('Promise resolver ' + resolver + ' is not a function')
        }
        if (!(this instanceof Promise)) return new Promise(resolver)
        var self = this // 保存this
        self.callbacks = [] // 保存onResolve和onReject函数集合
        self.status = 'pending' // 当前状态
        function resolve(value) {
            setTimeout(function() { //异步调用
                if (self.status !== 'pending') {
                    return
                }
                self.status = 'resolved' //修改状态
                self.data = value
                for (var i=0; i < self.callbacks.length; i++) {
                    self.callbacks[i].onResolved(value)
                }
            })
        }
        function reject(reason) {
            setTimeout(function(){ //异步调用
                if (self.status !== 'pending') {
                    return
                }
                self.status = 'rejected' //修改状态
                self.data = reason
                for (var i=0; i < self.callbacks.length; i++) {
                    self.callbacks[i].onRejected(reason)
                }
            })
        }
        try{
            resolver(resolve, reject) // 执行resolver函数
        } catch(e) {
            reject(e)
        }
    }
    function resolvePromise(promise, x, resolve, reject) {
        var then
        if ((x !== null) && ((typeof x === 'object') || (typeof x === 'function'))) {
            try {
                then = x.then
                if (typeof then === 'function') {
                    then.call(x, function rs(y) {
                        return resolvePromise(promise, y, resolve, reject)
                    }, function rj(r) {
                        return reject(r)
                    })
                } else {
                    return resolve(x)
                }
            } catch(e) {
                return reject(e)
            }
        } else {
            return resolve(x)
        }
    }
    Promise.prototype.then = function(onResolved, onRejected){
        var self = this
        var promise2
        if (self.status === 'pending') {
            return promise2 = new Promise(function(resolve, reject) {
                self.callbacks.push({
                    onResolved: function(value) {
                        try {
                            var x = onResolved(value)
                            resolvePromise(promise2, x, resolve, reject)
                        } catch(e) {
                            return reject(e)
                        }
                    },
                    onRejected: function(reason) {
                        try {
                            var x = onRejected(reason)
                            resolvePromise(promise2, x, resolve, reject)
                        } catch(e) {
                            return reject(e)
                        }
                    }
                })
            })
        }
        //promise状态为resolved
        if (self.status === 'resolved') {
            return promise2 = new Promise(function(resolve, reject) {
                setTimeout(function() {
                    try {
                        var x = onResolved(self.data)
                        resolvePromise(promise2, x, resolve, reject)
                    } catch(e) {
                        return reject(e)
                    }
                })
            })
        }
        //promise状态为rejected
        if (self.status === 'rejected') {
            return promise2 = new Promise(function(resolve, reject) {
                setTimeout(function() {
                    try {
                        var x = onRejected(self.data)
                        resolvePromise(promise2, x, resolve, reject)
                    } catch(e) {
                        return reject(e)
                    }
                })
            })
        }
    }
    try { // CommonJS compliance
        module.exports = Promise
    } catch(e) {}
    return Promise
})()

promise规范：https://www.jianshu.com/p/b4f0425b22a1

• 调用resolve或reject并不会终结 Promise 的参数函数的执行。
• 由于p2返回的是另一个 Promise，导致p2自己的状态无效了，由p1的状态决定p2的状态
• then方法的第一个参数是resolved状态的回调函数，第二个参数（可选）是rejected状态的回调函数。
• then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）
• Promise 的状态一旦改变，就永久保持该状态，不会再变了

参考：
https://mengera88.github.io/2017/05/18/Promise%E5%8E%9F%E7%90%86%E8%A7%A3%E6%9E%90/