1
class _Promise {
2
constructor(excutor) {
3
  this.state = "pending";
4

5
  this.resolveInfo = undefined;
6
  this.rejectInfo = undefined;
7

8
  this.resolveCb = [];
9

10
  this.rejectCb = [];
11

12
  const resolve = (value) => {
13
    if (this.state === "pending") {
14
      this.state = "fullfilled";
15
      this.resolveInfo = value;
16
      this.resolveCb.forEach((fn) => {
17
        fn(this.resolveInfo);
18
      });
19
    }
20
  };
21
  const reject = (value) => {
22
    if (this.state === "pending") {
23
      this.state = "rejected";
24
      this.rejectInfo = value;
25
      this.rejectCb.forEach((fn) => {
26
        fn(this.rejectInfo);
27
      });
28
    }
29
  };
30
  try {
31
    excutor(resolve, reject);
32
  } catch (error) {
33
    reject(error);
34
  }
35
}
36
then(onFullfilled, onRejected) {
37
  const innerPromise = new _Promise((resolve, reject) => {
38
    if (this.state === "fullfilled") {
39
      setTimeout(() => {
40
        try {
41
          const returnValue =
42
            typeof onFullfilled === "function"
43
              ? onFullfilled(this.resolveInfo)
44
              : (value) => value;
45
          _Promise.resolvePromise.apply(
46
            innerPromise,
47
            returnValue,
48
            resolve,
49
            reject
50
          );
51
        } catch (error) {
52
          reject(error);
53
        }
54
      }, 0);
55
    }
56
    if (this.state === "rejected") {
57
      setTimeout(() => {
58
        try {
59
          const returnValue =
60
            typeof onRejected === "function"
61
              ? onRejected(this.rejectInfo)
62
              : (value) => value;
63
          _Promise.resolvePromise.apply(
64
            innerPromise,
65
            returnValue,
66
            resolve,
67
            reject
68
          );
69
        } catch (error) {
70
          reject(error);
71
        }
72
      }, 0);
73
    }
74
    if (this.state === "pending") {
75
      this.resolveCb.push(() => {
76
        setTimeout(() => {
77
          try {
78
            const returnValue =
79
              typeof onFullfilled === "function"
80
                ? onFullfilled(this.resolveInfo)
81
                : (value) => value;
82
            _Promise.resolvePromise.apply(
83
              innerPromise,
84
              returnValue,
85
              resolve,
86
              reject
87
            );
88
          } catch (error) {
89
            reject(error);
90
          }
91
        }, 0);
92
      });
93
      this.rejectCb.push(() => {
94
        setTimeout(() => {
95
          try {
96
            const returnValue =
97
              typeof onRejected === "function"
98
                ? onRejected(this.rejectInfo)
99
                : (value) => value;
100
            _Promise.resolvePromise.apply(
101
              innerPromise,
102
              returnValue,
103
              resolve,
104
              reject
105
            );
106
          } catch (error) {
107
            reject(error);
108
          }
109
        }, 0);
110
      });
111
    }
112
  });
113
  return innerPromise;
114
}
115

116
static resolvePromise(newPromise, returnValue, resolve, reject) {
117
  if (newPromise === returnValue) {
118
    return reject(new Error("不能重复引用"));
119
  }
120
  // 防止多次调用
121
  let called;
122

123
  if (
124
    returnValue instanceof _Promise &&
125
    typeof returnValue.then === "function"
126
  ) {
127
    returnValue.then(
128
      (innerResolveMsg) => {
129
        if (called) return;
130
        called = true;
131
        resolvePromise(newPromise, innerResolveMsg, resolve, reject);
132
      },
133
      (innerRejectedMsg) => {
134
        if (called) return;
135
        called = true;
136
        resolvePromise(newPromise, innerRejectedMsg, resolve, reject);
137
      }
138
    );
139
  } else {
140
    resolve(returnValue);
141
  }
142
}
143
}