Promise对象代表了未来将要发生的事情，用来传递异步操作的消息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
const PENDING = 'PENDING'   // 进行中
const FULFILLED = 'FULFILLED'   // 已成功
const REJECTED = 'REJECTED'     // 已失败

class Promise {
    constructor(executor) {
        // 初始化状态
        this.status = PENDING
        // 将成功、失败结果放在 this 上，便于then、catch访问
        this.value = undefined
        this.reason = undefined
        // 成功状态回调函数队列
        this.onFulfilledCallbacks = []
        // 失败状态回调函数队列
        this.onRejectedCallbacks = []

        const resolve = value => {
            // 只有进行中状态才能更改状态
            if (this.status === PENDING) {
                this.status = FULFILLED
                this.value = value
                // 执行成功状态的回调函数队列
                this.onFulfilledCallbacks.forEach(fn => fn(this.value))
            }
        }

        const reject = reson => {
            if (this.status === PENDING) {
                this.status = REJECTED
                this.reason = reason
                this.onRejectedCallbacks.forEach(fn => fn(this.reason))
            }
        }

        try {
            // 立即执行executor
            executor(resolve, reject)
        } catch (e) {
            reject(e)
        }
    }

    then(onFulfilled, onRejected) {
        onFulfilled =
            typeof onFulfilled === 'function'
            ? onFulfilled
            : value => value
        onRejected =
            typeof onRejected === 'function'
            ? onRejected
            : reason => {
                throw new Error(
                    reason instanceof Error
                    ? reason.message
                    : reason)
            }

        const self = this
        return new Promise((resolve, reject) => {
            if (self.status === PENDING) {
                self.onFulfilledCallbacks.push(() => {
                    try {
                        setTimeout(() => {
                            const result = onFulfilled(self.value)
                            result instanceof Promise
                                ? result.then(resolve, reject)
                                : resolve(result)
                        }, 0)
                    } catch (e) {
                        reject(e)
                    }
                })
                self.onRejectedCallbacks.push(() => {
                    try {
                        setTimeout(() => {
                            const result = onRejected(self.reason)
                            result instanceof Promise
                                ? result.then(resolve, reject)
                                : reject(result)
                        }, 0)
                    } catch (e) {
                        reject(e)
                    }
                })
            } else if (self.status === FULFILLED) {
                try {
                    setTimeout(() => {
                        const result = onFulfilled(self.value)
                        result instanceof Promise
                            ? result.then(resolve, reject)
                            : resolve(result)
                    }, 0)
                } catch (e) {
                    reject(e)
                }
            } else if (self.status === REJECTED) {
                try {
                    setTimeout(() => {
                        const result = onRejected(self.reason)
                        result instanceof Promise
                            ? result.then(resolve, reject)
                            : reject(result)
                    })
                } catch (e) {
                    reject(e)
                }
            }
        })
    }

    catch(onRejected) {
        return this.then(null, onRejected)
    }

    static resolve(value) {
        if (value instanceof Promise) {
            return value
        } else {
            return new Promise((resolve, reject) => resolve(value))
        }
    }
    static reject(reason) {
        return new Promise((resolve, reject) => {
            reject(reason)
        })
    }
}