1. const RESOLVE = 'resolved';
    2. const REJECT = 'rejected';
    3. const PENDING = 'pending';
    5. const handlePromise = (result,newPromise,resolve,reject) => {
    6.     if(result === newPromise){
    7.         throw new Error("can't not return oneself")
    8.     }
    10.     if((typeof result === 'object' && typeof result !== null) || typeof result === 'function'){
    11.         let lock = false
    12.         try {
    13.             const then = result.then;
    14.             if(typeof then === 'function'){
    15.                 then.call(result,(r)=>{
    16.                     if(lock) return ;
    17.                     handlePromise(r,newPromise,resolve,reject);
    18.                     lock = true
    19.                 },(e)=>{
    20.                     if(lock) return ;
    21.                     reject(e);
    22.                     lock = true;
    23.                 })
    24.             }else{
    25.                 resolve(result)
    26.             }
    27.         } catch(error){
    28.             reject(error)
    29.         }
    32.     }else{
    33.         resolve(result)
    34.     }
    35. }
    37. class JJPromise {
    38.     status = PENDING;
    39.     result = undefined;
    40.     reason = undefined;
    41.     onResolveArr = [];
    42.     onRejectArr = [];
    43.     constructor(excution){
    44.         const resolve = (result) => {
    45.             if(this.status === PENDING){
    46.                 this.result = result;
    47.                 this.status = RESOLVE;
    48.                 this.onResolveArr.map((fn) => fn())
    49.             }
    50.         }
    52.         const reject = (reason) => {
    53.             if(this.status === PENDING){
    54.                 this.reason = reason;
    55.                 this.status = REJECT;
    56.                 this.onRejectArr.map((fn) => fn())
    57.             }
    58.         }
    59.         try {
    60.             excution(resolve,reject)
    61.         } catch(error) {
    62.             reject(error);
    63.         }
    66.     }
    68.     then(onResolved,onRejected){
    69.         onResolved = typeof onResolved === 'function' ? onResolved : (data) => data;
    70.         onRejected = typeof onRejected === 'function' ? onRejected : (err) => {
    71.             throw new Error(err)
    72.         }
    74.         const newPromise = new JJPromise((resolve,reject) => {
    75.             if(this.status === RESOLVE){
    76.                 setTimeout(() => {
    77.                     try {
    78.                         const result = onResolved(this.result)
    79.                         handlePromise(result,newPromise,resolve,reject);
    80.                     } catch(error) {
    81.                         reject(error)
    82.                     }
    83.                 },0)
    84.             }
    85.             if(this.status === REJECT){
    86.                 setTimeout(() => {
    87.                     try {
    88.                         const result = onRejected(this.reason)
    89.                         handlePromise(result,newPromise,resolve,reject);
    90.                     } catch(error) {
    91.                         reject(error)
    92.                     }
    94.                 },0)
    95.             }
    96.             if(this.status === PENDING){
    97.                 this.onResolveArr.push(()=>{
    98.                     try {
    99.                         const result = onResolved(this.result)
    100.                         handlePromise(result,newPromise,resolve,reject);
    101.                     } catch(error) {
    102.                         reject(error)
    103.                     }
    105.                 })
    106.                 this.onRejectArr.push(()=>{
    107.                     try {
    108.                         const result = onRejected(this.result)
    109.                         handlePromise(result,newPromise,resolve,reject);
    110.                     } catch(error) {
    111.                         reject(error)
    112.                     }
    114.                 })
    115.             }
    116.         })
    117.         return newPromise;   
    118.     }
    120.     catch(onRejected){
    121.         return this.then(undefined,onRejected);
    122.     }
    123. }
    125. const test = new JJPromise((resolve,reject) => {
    126.     resolve('123')
    127. })
    130. test.then((res) => {console.log(res)})
    131. console.log('1')
    133. // 1
    134. // 123