webpack基础小结。

参考 Promise A+ 简单实现 promise,用的setTimeout 模拟的异步，与实际浏览器Promise 有出入（具体可以看Event loop 相关），本文只做思路理解参考。

Promise 的简单实现，主要理解规范，也可以再理解一下几个点方变记忆：

• Promise的三种状态（pending，fulfilled，rejected）, pending状态转移后不可变
• resolve , resolve a promise with a promise
• reject
• Promise.prototype.then 返回一个新的promise 对象（链式操作）
• thenable对象

1.简单实现

 const PENDING = 'pending'
 const FULFILLED = 'fulfilled'
 const REJECTED = 'rejected'

 function needResolve() {
   throw new TypeError('need pass function to Promise')
 }

 function needuseNew() {
   throw new TypeError(
     'Promise is a constructor and should be called with the `new` keyword'
   )
 }

 function Promise(task) {
   var self = this
   this.state = PENDING
   this.value
   this.fulArr = []
   this.rejArr = []

   function resolve(value) {
     if (value != null && value.then && typeof value.then == 'function') {
       return value.then(resolve, reject)
     }
     setTimeout(() => {
       if (self.state == PENDING) {
         self.state = FULFILLED
         self.value = value
         self.fulArr.forEach(item => {
           item(self.value)
         })
       }
     })
   }

   function reject(reason) {
     setTimeout(() => {
       if (self.state == PENDING) {
         self.state = REJECTED
         self.value = reason
         self.fulArr.forEach(item => {
           item(self.value)
         })
       }
     })
   }
   typeof task !== 'function' && needResolve()
   !(this instanceof Promise) && needResolve()
   try {
     task(
       function(value) {
         resolve(value)
       },
       function(reason) {
         reject(reason)
       }
     )
   } catch (e) {
     reject(e)
   }
 }

 function resolvePromise(promise, x, resolve, reject) {
   if (promise === x) {
     return reject(new TypeError('do not resolve promise with itself'))
   }
   var then, called
   // resolve promise with promise
   if (x instanceof Promise) {
     if (x.status == PENDING) {
       x.then(function(y) {
         resolvePromise(promise, y, resolve, reject)
       }, reject)
     } else {
       x.then(resolve, reject)
     }
     // thenable 其它的then
   } else if (x !== null && (typeof x == 'function' || typeof x == 'object')) {
     try {
       // resolve promise with promise
       then = x.then
       if (typeof then === 'function') {
         then.call(
           x,
           function(y) {
             if (called) {
               return
             }
             called = true
             resolvePromise(promise, y, resolve, reject)
           },
           function(r) {
             if (called) {
               return
             }
             called = true
             reject(r)
           }
         )
       } else {
         resolve(x)
       }
     } catch (e) {
       if (called) {
         return
       }
       called = true
       reject(e)
     }
   } else {
     resolve(x)
   }
 }
 Promise.prototype.then = function(onFulfilled, onRejected) {
   var self = this
   onFulfilled =
     typeof onFulfilled === 'function'
       ? onFulfilled
       : function(value) {
           return value
         }
   onRejected =
     typeof onRejected === 'function'
       ? onRejected
       : function(reason) {
           throw reason
         }
   var promise2
   if (self.state == PENDING) {
     promise2 = new Promise(function(resolve, reject) {
       self.fulArr.push(value => {
         try {
           let x = onFulfilled(value)
           resolvePromise(promise2, x, resolve, reject)
         } catch (e) {
           reject(e)
         }
       })
       self.reject.push(reason => {
         try {
           let x = onRejected(reason)
           resolvePromise(promise2, x, resolve, reject)
         } catch (e) {
           reject(e)
         }
       })
     })
   }
   if (self.state == FULFILLED) {
     promise2 = new Promise(function(resolve, reject) {
       setTimeout(() => {
         try {
           let x = onFulfilled(self.value)
           resolvePromise(promise2, x, resolve, reject)
         } catch (e) {
           reject(e)
         }
       })
     })
   }
   if (self.state == REJECTED) {
     promise2 = new Promise(function(resolve, reject) {
       setTimeout(() => {
         try {
           let x = onRejected(self.value)
           resolvePromise(promise2, x, resolve, reject)
         } catch (e) {
           reject(e)
         }
       })
     })
   }
   // then 必须返回一个新的promise
   return promise2
 }

 Promise.prototype.catch = function(onRejected) {
   return this.then(null, onRejected)
 }

 Promise.resolve = function(value) {
   return new Promise((resolve, reject) => {
     resolve(value)
   })
 }
 Promise.reject = function(value) {
   return new Promise((resolve, reject) => {
     reject(value)
   })
 }

 function gen(time, resolve) {
   let result = []
   let i = 0
   return function(index, value) {
     if (i < time) {
       i++
       result[index] = value
     } else {
       resolve(result)
     }
   }
 }

 Promise.race = function(arr) {
   return new Promise((resolve, reject) => {
     for (let i = 0; i < arr.length; i++) {
       Promise.resolve(arr[i]).then(resolve, reject)
     }
   })
 }
 Promise.all = function(arr) {
   return new Promise((resolve, reject) => {
     let done = gen(arr.length, resolve)
     for (let i = 0; i < arr.length; i++) {
       Promise.resolve(arr[i]).then(function(value) {
         done(value, i)
       }, reject)
     }
   })
 }
 module.exports = Promise