最近在搞秋招，发现自己的还有很多不足，特地的来复习一下之前所学的知识，坐下笔记巩固一下

代码实现

类似于发布订阅模式的状态存储-来实现异步的回调

  1.     class Promise(){
  2.         constructor(executor){      // executor 自执行函数
  3.             this.state = 'pending'  // 设置默认的状态 一共有 pending fulfilled rejected
  4.             this.value = undefined  // 设置成功时 存储返回的值
  5.             this.reason = undefined  // 设置失败时 存储失败的原因
  6.             this.onFulfilledCallback = []   //存储成功时的回调函数
  7.             this.onRejectedCallback = [];
  9.             // 分别定义 resolve reject函数定义状态触发时的执行方法
  10.             this.resolve = value=>{
  11.                 if(this.state === 'pending'){
  12.                     this.state = 'fulfilled'
  13.                     this.value = value
  14.                     this.onFulfilledCallback.forEach(fn=> f())
  15.                 }
  16.             }
  17.             this.reject = reason=>{
  18.                 if(this.tate === 'pending'){
  19.                     this.state = 'rejecteed'
  20.                     this.reason = reason
  21.                     this.onRejectedCallback.forEach(fn=> fn())
  22.                 }
  23.             }
  24.             try{
  25.                 executor(reslove,reject)
  26.             }catch(e){
  27.                 reject(e)
  28.             }
  29.         }
  30.         // 定义then方法
  31.         then() .....
  33.     }

实现then异步调用

  1. class Promis(){
  2.     constructor(executor){ .....
  3.   then(onFulfilled,onRejected){
  4.       // 如果没有函数的设置适配器（默认函数）
  5.     onFulfilled = typeOf onFulfilled === 'function' ? onFulfilled : value=> value;
  6.     onRejected = typeOf onRejected === 'function' ? onRejected ： err = {throw err}
  8.     let promise2 = new Promise((resolve,reject)=>{
  9.         //三种状态 
  10.       // ————成功
  11.         if(this.state === 'fulfilled'){  
  12.           setTimeout(()=>{                
  13.                 var x = onFulfilleded(this.value)   // 先执行当前then的回调函数， 并得到返回值
  14.             reslovePromise(promise2,x,reslove,reject)   // 如果有返回值执行自定义的函数
  15.         },0)
  16.       }
  17.       // ———失败
  18.         if(this.state === 'rejected'){ 
  19.           setTimeout(()=>{                
  20.                 var x = onRejected(this.value)   
  21.             reslovePromise(promise2,x,reslove,reject)   
  22.         },0)
  23.       }
  24.       // ———异步中（还在pending）
  25.       if(this,state === 'pending'){    // 此时为异步调用分别将他们的函数推入定义的执行栈
  26.               this.onFulfilledCallback.push(
  27.               setTimeout(()=>{
  28.                 let x = oFulfilled(this.value)
  29.               reslovePromise(promise2,x,reslove,reject)   
  30.             },0)
  31.           )
  32.             this.onRejectedCallback.push({
  33.               setTimeout(()=>{
  34.                 let x = onRejected(this.reason)
  35.               reslovePromise(promise2,x,reslove,reject)   
  36.             },0)
  37.           })
  38.       }
  39.     })
  40.   }
  42. }

问题1——为啥能实现异步的回调呢

我们来看看最初实现异步操作的—回调

  1. // f1 假设它为异步的操作
  2. function f1(){
  3.     setTimeout(()=>{ja
  4.        ... 执行f1后面的操作
  6.       f2();     // 执行f2()
  7.    },1000)
  8. }
  9. //这样就保证了f2的在f1后面执行-保障了执行的顺序

我们来看看promise是怎么定义的

  1. var p = new Promise(resolve=>{
  2.     fs.readFile('input.txt', function (err, data) {
  3.      if (err) {
  4.          return console.error(err);
  5.      }
  6.      resolve(data)
  7.   });
  8. })

她其实也是将后续操作（回调函数等）定义到后面，
1.所以当promise执行当then时发现异步函数还未执行完，于是将他推入执行栈内，
2.当异步函数执行完之后，执行resolve函数，这就像是自执行的订阅行为，（当异步函数还没执行完的时 候，发布其回调函数给promise，当执行完之后调用resolve订阅得到函数）

问题2——为啥要使用setTimout呢

如果在then方法注册回调之前，resolve函数就执行了，怎么办？比如promise内部的函数是同步函数

  1.     function getUserId() {
  2.     return new Promise(function (resolve) {
  3.         resolve(9876);
  4.     });
  5. }
  6. getUserId().then(function (id) {
  7.     // 一些处理
  8. });

Promises/A+规范明确要求回调需要通过异步方式执行，用以保证一致可靠的执行顺序。因此我们要加入一些处理，保证在resolve执行之前

实现relovePromise函数

  1. function reslovePromise(promise2,x,reslove,reject){
  2.      // 防止自身循环调用
  3.       if(x === promise2){
  4.       return reject(new TypeError('Chaining cycle detected for promise')) 
  5.     }
  6.      let called = false // 检测他是否调用过
  7.     if(x !== null && (typeof x === 'function' || typeof x === 'object')){
  8.         // 返回的是一个promise对象
  9.         try{
  10.             const then = x.then;
  11.             if(typeof then === 'fuction'){
  12.                  then.call(x,value=>{
  13.                     if(reject) return 
  14.                     reject = true
  15.                     reslovePromise(promise2,value,resolve,reject)
  16.                 },reason=>{
  17.                     if(reject) return 
  18.                     reject = true
  19.                     reject(reason)
  20.                 })   
  21.             }else{
  22.                 if(reject) return 
  23.                 reject = true
  24.                 resolve(x)
  25.             }
  26.         }catch(e){
  27.             if(reject) return 
  28.             reject = true
  29.              reject(e)  
  30.         }
  31.     }else{
  32.         // 返回的是一个普通的值
  33.          relove(x)       
  34.     }
  35. }

问题3——什么时候会发生循环调用

  1. let p = new Promise( resolve =>{
  2.         resolve(x)
  3.       })
  4.       let p2 = p.then( ()=>{
  5.         return p2
  6.       })

问题4——为什么要使用try-catch语句

  1. var obj = {};
  2. Object.defineProperty(obj,'a',{
  3.     get:function () {
  4.         return new Error('hhhhh');
  5.     }
  6. })

当对象定义了defineProperty的时候，如获取属性时抛出错误，就会发生错误

问题4——called是干啥的

peomise要保证内的状态的变化是单向的，当一次执行时内部的状态发生了改变，就不允许再次调用；