首发地址:sau交流学习社区

一、前言

什么是promise?promsie的核心是什么?promise如何解决回调地狱的?等问题

1、什么是promise?promise是表示异步操作的最终结果;可以用来解决回调地狱和并发IO操作的问题

A promise represents the eventual result of an asynchronous operation.

2、promise 的核心是什么?promise的核心就是链式调用

3、采用什么方法可以实现链式调用?通过使用then的方法,then方法是用来注册在这个Promise状态确定后的回调,很明显,then方法需要写在原型链上。

4、promise是如何解决回调地狱的问题?(1)如果一个promise返回的是一个promise,会把这个promise传递结果传递到下一次的then中;(2)如果一个promise返回的是一个普通的值,会把这个普通值作为下一次then的成功回调结果;(3)如果当前promise失败了,会走下一个then的回调函数;(4)如果then不返回值,就会有一个默认值为undefined,作为普通值,会作为下一个then的成功回调;(5)catch是错误没有处理的情况才会执行;(6)then中可以不写东西

二、promise的标准解读

1、只有一个then方法,没有catchraceall等方法,甚至没有构造函数;

Promise标准中仅指定了Promise对象的then方法的行为,其它一切我们常见的方法/函数都并没有指定,包括catchraceall等常用方法,甚至也没有指定该如何构造出一个Promise对象,另外then也没有一般实现中(Q, $q等)所支持的第三个参数,一般称onProgress

2、then方法返回一个新的Promise;

Promise的then方法返回一个新的Promise,而不是返回this,此处在下文会有更多解释

  1. promise2 = promise1.then(alert)
  2. promise2 != promise1 // true

3、不同Promise的实现需要可以相互调用(interoperable)

4、Promise的初始状态为pending,它可以由此状态转换为fulfilled(本文为了一致把此状态叫做resolved)或者rejected,一旦状态确定,就不可以再次转换为其它状态,状态确定的过程称为settle

三、实现一个promise

1、构造函数

因为标准并没有指定如何构造一个Promise对象,所以我们同样以目前一般Promise实现中通用的方法来构造一个Promise对象,也是ES6原生Promise里所使用的方式,即:

  1. // Promise构造函数接收一个executor函数,executor函数执行完同步或异步操作后,调用它的两个参数resolve和reject
  2. var promise = new Promise(function(resolve, reject) {
  3. /*
  4. 如果操作成功,调用resolve并传入value
  5. 如果操作失败,调用reject并传入reason
  6. */
  7. })

我们先实现构造函数的框架如下:

  1. function Promise(executor) {
  2. var self = this
  3. self.status = 'pending' // Promise当前的状态
  4. self.data = undefined // Promise的值
  5. self.onResolvedCallback = [] // Promise resolve时的回调函数集,因为在Promise结束之前有可能有多个回调添加到它上面
  6. self.onRejectedCallback = [] // Promise reject时的回调函数集,因为在Promise结束之前有可能有多个回调添加到它上面
  7. executor(resolve, reject) // 执行executor并传入相应的参数
  8. }

上面的代码基本实现了Promise构造函数的主体,但目前还有两个问题:

1、我们给executor函数传了两个参数:resolve和reject,这两个参数目前还没有定义

2、executor有可能会出错(throw),类似下面这样,而如果executor出错,Promise应该被其throw出的值reject:

  1. new Promise(function(resolve, reject) {
  2. throw 2
  3. })

所以我们需要在构造函数里定义resolve和reject这两个函数:

  1. function Promise(executor) {
  2. var self = this
  3. self.status = 'pending' // Promise当前的状态
  4. self.data = undefined // Promise的值
  5. self.onResolvedCallback = [] // Promise resolve时的回调函数集,因为在Promise结束之前有可能有多个回调添加到它上面
  6. self.onRejectedCallback = [] // Promise reject时的回调函数集,因为在Promise结束之前有可能有多个回调添加到它上面
  7. function resolve(value) {
  8. // TODO
  9. }
  10. function reject(reason) {
  11. // TODO
  12. }
  13. try { // 考虑到执行executor的过程中有可能出错,所以我们用try/catch块给包起来,并且在出错后以catch到的值reject掉这个Promise
  14. executor(resolve, reject) // 执行executor
  15. } catch(e) {
  16. reject(e)
  17. }
  18. }

有人可能会问,resolve和reject这两个函数能不能不定义在构造函数里呢?考虑到我们在executor函数里是以resolve(value)reject(reason)的形式调用的这两个函数,而不是以resolve.call(promise, value)reject.call(promise, reason)这种形式调用的,所以这两个函数在调用时的内部也必然有一个隐含的this,也就是说,要么这两个函数是经过bind后传给了executor,要么它们定义在构造函数的内部,使用self来访问所属的Promise对象。所以如果我们想把这两个函数定义在构造函数的外部,确实是可以这么写的:

  1. function resolve() {
  2. // TODO
  3. }
  4. function reject() {
  5. // TODO
  6. }
  7. function Promise(executor) {
  8. try {
  9. executor(resolve.bind(this), reject.bind(this))
  10. } catch(e) {
  11. reject.bind(this)(e)
  12. }
  13. }

但是众所周知,bind也会返回一个新的函数,这么一来还是相当于每个Promise对象都有一对属于自己的resolve和reject函数,就跟写在构造函数内部没什么区别了,所以我们就直接把这两个函数定义在构造函数里面了。不过话说回来,如果浏览器对bind的所优化,使用后一种形式应该可以提升一下内存使用效率。

另外我们这里的实现并没有考虑隐藏this上的变量,这使得这个Promise的状态可以在executor函数外部被改变,在一个靠谱的实现里,构造出的Promise对象的状态和最终结果应当是无法从外部更改的

接下来,我们实现resolve和reject这两个函数

  1. function Promise(executor) {
  2. // ...
  3. function resolve(value) {
  4. if (self.status === 'pending') {
  5. self.status = 'resolved'
  6. self.data = value
  7. for(var i = 0; i < self.onResolvedCallback.length; i++) {
  8. self.onResolvedCallback[i](value)
  9. }
  10. }
  11. }
  12. function reject(reason) {
  13. if (self.status === 'pending') {
  14. self.status = 'rejected'
  15. self.data = reason
  16. for(var i = 0; i < self.onRejectedCallback.length; i++) {
  17. self.onRejectedCallback[i](reason)
  18. }
  19. }
  20. }
  21. // ...
  22. }

基本上就是在判断状态为pending之后把状态改为相应的值,并把对应的value和reason存在self的data属性上面,之后执行相应的回调函数,逻辑很简单,这里就不多解释了。

2、then方法

then方法是用来注册这个promise确定状态后的回调,then方法是需要写在原型链上。

自然约束:then方法会返回一个Promise,关于这一点,Promise/A+标准并没有要求返回的这个Promise是一个新的对象,但在Promise/A标准中,明确规定了then要返回一个新的对象,目前的Promise实现中then几乎都是返回一个新的Promise(https://promisesaplus.com/differences-from-promises-a#point-5)对象,所以在我们的实现中,也让then返回一个新的Promise对象。

下面我们来实现then方法:

  1. // then方法接收两个参数,onResolved,onRejected,分别为Promise成功或失败后的回调
  2. Promise.prototype.then = function(onResolved, onRejected) {
  3. var self = this
  4. var promise2
  5. // 根据标准,如果then的参数不是function,则我们需要忽略它,此处以如下方式处理
  6. onResolved = typeof onResolved === 'function' ? onResolved : function(v) {}
  7. onRejected = typeof onRejected === 'function' ? onRejected : function(r) {}
  8. if (self.status === 'resolved') {
  9. return promise2 = new Promise(function(resolve, reject) {
  10. })
  11. }
  12. if (self.status === 'rejected') {
  13. return promise2 = new Promise(function(resolve, reject) {
  14. })
  15. }
  16. if (self.status === 'pending') {
  17. return promise2 = new Promise(function(resolve, reject) {
  18. })
  19. }
  20. }

Promise总共有三种可能的状态,我们分三个if块来处理,在里面分别都返回一个new Promise。

根据标准,我们知道,对于如下代码,promise2的值取决于then里面函数的返回值:

  1. promise2 = promise1.then(function(value) {
  2. return 4
  3. }, function(reason) {
  4. throw new Error('sth went wrong')
  5. })

如果promise1被resolve了,promise2的将被`4` resolve,如果promise1被reject了,promise2将被`new Error('sth went wrong')` reject,更多复杂的情况不再详述。

3、完整的promise

  1. try {
  2. module.exports = Promise
  3. } catch (e) {}
  4. function Promise(executor) {
  5. var self = this
  6. self.status = 'pending'
  7. self.onResolvedCallback = []
  8. self.onRejectedCallback = []
  9. function resolve(value) {
  10. if (value instanceof Promise) {
  11. return value.then(resolve, reject)
  12. }
  13. setTimeout(function() { // 异步执行所有的回调函数
  14. if (self.status === 'pending') {
  15. self.status = 'resolved'
  16. self.data = value
  17. for (var i = 0; i < self.onResolvedCallback.length; i++) {
  18. self.onResolvedCallback[i](value)
  19. }
  20. }
  21. })
  22. }
  23. function reject(reason) {
  24. setTimeout(function() { // 异步执行所有的回调函数
  25. if (self.status === 'pending') {
  26. self.status = 'rejected'
  27. self.data = reason
  28. for (var i = 0; i < self.onRejectedCallback.length; i++) {
  29. self.onRejectedCallback[i](reason)
  30. }
  31. }
  32. })
  33. }
  34. try {
  35. executor(resolve, reject)
  36. } catch (reason) {
  37. reject(reason)
  38. }
  39. }
  40. function resolvePromise(promise2, x, resolve, reject) {
  41. var then
  42. var thenCalledOrThrow = false
  43. if (promise2 === x) {
  44. return reject(new TypeError('Chaining cycle detected for promise!'))
  45. }
  46. if (x instanceof Promise) {
  47. if (x.status === 'pending') { //because x could resolved by a Promise Object
  48. x.then(function(v) {
  49. resolvePromise(promise2, v, resolve, reject)
  50. }, reject)
  51. } else { //but if it is resolved, it will never resolved by a Promise Object but a static value;
  52. x.then(resolve, reject)
  53. }
  54. return
  55. }
  56. if ((x !== null) && ((typeof x === 'object') || (typeof x === 'function'))) {
  57. try {
  58. then = x.then //because x.then could be a getter
  59. if (typeof then === 'function') {
  60. then.call(x, function rs(y) {
  61. if (thenCalledOrThrow) return
  62. thenCalledOrThrow = true
  63. return resolvePromise(promise2, y, resolve, reject)
  64. }, function rj(r) {
  65. if (thenCalledOrThrow) return
  66. thenCalledOrThrow = true
  67. return reject(r)
  68. })
  69. } else {
  70. resolve(x)
  71. }
  72. } catch (e) {
  73. if (thenCalledOrThrow) return
  74. thenCalledOrThrow = true
  75. return reject(e)
  76. }
  77. } else {
  78. resolve(x)
  79. }
  80. }
  81. Promise.prototype.then = function(onResolved, onRejected) {
  82. var self = this
  83. var promise2
  84. onResolved = typeof onResolved === 'function' ? onResolved : function(v) {
  85. return v
  86. }
  87. onRejected = typeof onRejected === 'function' ? onRejected : function(r) {
  88. throw r
  89. }
  90. if (self.status === 'resolved') {
  91. return promise2 = new Promise(function(resolve, reject) {
  92. setTimeout(function() { // 异步执行onResolved
  93. try {
  94. var x = onResolved(self.data)
  95. resolvePromise(promise2, x, resolve, reject)
  96. } catch (reason) {
  97. reject(reason)
  98. }
  99. })
  100. })
  101. }
  102. if (self.status === 'rejected') {
  103. return promise2 = new Promise(function(resolve, reject) {
  104. setTimeout(function() { // 异步执行onRejected
  105. try {
  106. var x = onRejected(self.data)
  107. resolvePromise(promise2, x, resolve, reject)
  108. } catch (reason) {
  109. reject(reason)
  110. }
  111. })
  112. })
  113. }
  114. if (self.status === 'pending') {
  115. // 这里之所以没有异步执行,是因为这些函数必然会被resolve或reject调用,而resolve或reject函数里的内容已是异步执行,构造函数里的定义
  116. return promise2 = new Promise(function(resolve, reject) {
  117. self.onResolvedCallback.push(function(value) {
  118. try {
  119. var x = onResolved(value)
  120. resolvePromise(promise2, x, resolve, reject)
  121. } catch (r) {
  122. reject(r)
  123. }
  124. })
  125. self.onRejectedCallback.push(function(reason) {
  126. try {
  127. var x = onRejected(reason)
  128. resolvePromise(promise2, x, resolve, reject)
  129. } catch (r) {
  130. reject(r)
  131. }
  132. })
  133. })
  134. }
  135. }
  136. Promise.prototype.catch = function(onRejected) {
  137. return this.then(null, onRejected)
  138. }
  139. Promise.deferred = Promise.defer = function() {
  140. var dfd = {}
  141. dfd.promise = new Promise(function(resolve, reject) {
  142. dfd.resolve = resolve
  143. dfd.reject = reject
  144. })
  145. return dfd
  146. }

四、promise的常用方法是如何实现

1、Promise.resolve / Promise.reject 实现

  1. // 原生的Promise.resolve使用
  2. Promise.resolve('hello swr').then((data)=>{ // 直接把成功的值传递给下一个then
  3. console.log(data) // hello swr
  4. })
  5. // 那么Promise.resolve内部是怎么实现的呢?
  6. Promise.resolve = function(value){
  7. return new Promise((resolve,reject)=>{ // 在内部new一个Promise对象
  8. resolve(value)
  9. })
  10. }
  11. // 同理,Promise.reject内部也是类似实现的
  12. Promise.reject = function(reason){
  13. return new Promise((resolve,reject)=>{
  14. reject(reason)
  15. })
  16. }

2、catch的实现

  1. // 原生Promise的catch使用
  2. Promise.reject('hello swr').catch((e)=>{
  3. console.log(e) // hello swr
  4. })
  5. // 上面这段代码相当于下面这段代码
  6. Promise.reject('hello swr').then(null,(e)=>{ // then里直接走了失败的回调
  7. console.log(e) // hello swr
  8. })
  9. // 内部实现
  10. Promise.prototype.catch = function(onRejected){
  11. return this.then(null,onRejected) // 相当于then里的成功回调只传个null
  12. }

3、promise.all的实现同时执行多个异步,并且返回一个新的promise,成功的值是一个数组,该数组的成员的顺序是传参给promise.all的顺序

  1. // 原生Promise.all的使用
  2. // 假设1.txt内容为hello 2.txt内容为swr
  3. let fs = require('fs')
  4. function read(filePath,encoding){
  5. return new Promise((resolve,reject)=>{
  6. fs.readFile(filePath,encoding,(err,data)=>{
  7. if(err) reject(err)
  8. resolve(data)
  9. })
  10. })
  11. }
  12. Promise.all([read('./1.txt','utf8'),read('./2.txt','utf8')]).then((data)=>{
  13. console.log(data) // 全部读取成功后返回 ['hello','swr']
  14. // 需要注意的是,当其中某个失败的话,则会走失败的回调函数
  15. })

promise.all内部实现

  1. Promise.all = function(promises){ // promises 是一个数组
  2. return new Promise((resolve,reject)=>{
  3. let arr = []
  4. let i = 0
  5. function processData(index,data){
  6. arr[index] = data
  7. // 5.我们能用arr.length === promises.length来判断请求是否全部完成吗?
  8. // 答案是不行的,假设arr[2] = 'hello swr'
  9. // 那么打印这个arr,将是[empty × 2, "hello swr"],
  10. // 此时数组长度也是为3,而数组arr[0] arr[1]则为空
  11. // 那么换成以下的办法
  12. if(++i === promises.length){ // 6.利用i自增来判断是否都成功执行
  13. resolve(arr) // 此时arr 为['hello','swr']
  14. }
  15. }
  16. for(let i = 0;i < promises.length;i++){ // 1.在此处遍历执行
  17. promises[i].then((data)=>{ // 2.data是成功后返回的结果
  18. processData(i,data) // 4.因为Promise.all最终返回的是一个数组成员按照顺序排序的数组
  19. // 而且异步执行,返回并不一定按照顺序
  20. // 所以需要传当前的i
  21. },reject) // 3.如果其中有一个失败的话,则调用reject
  22. }
  23. })
  24. }

4、promise.race方法实现,同时执行多个异步,然后那个快,就用那个的结果,race是赛跑

  1. // 原生Promise.race的使用
  2. // 一个成功就走成功的回调,一个失败就走失败的回调
  3. Promise.race([read('./1.txt','utf8'),read('./2.txt','utf8')]).then((data)=>{
  4. console.log(data) // 可能返回 'hello' 也可能返回 'swr' 看哪个返回快就用哪个作为结果
  5. })
  6. // 内部实现
  7. Promise.race = function(promises){ // promises 是一个数组
  8. return new Promise((resolve,reject)=>{
  9. for(let i = 0;i < promises.length;i++){
  10. promises[i].then(resolve,reject) // 和上面Promise.all有点类似
  11. }
  12. })
  13. }

5、promise.defer = promise.deferred这个语法糖怎么理解呢?

这个语法糖可以简化一些操作,比如:

  1. let fs = require('fs')
  2. // 写法一:
  3. function read(filePath,encoding){
  4. // 这里的new Promise依然是传递了一个executor回调函数
  5. // 我们该怎样减少回调函数嵌套呢?
  6. return new Promise((resolve,reject)=>{
  7. fs.readFile(filePath,encoding,(err,data)=>{
  8. if(err) reject(err)
  9. resolve(data)
  10. })
  11. })
  12. }
  13. // 写法二:
  14. // 这样的写法减少了一层回调函数的嵌套
  15. function read(filePath,encoding){
  16. let dfd = Promise.defer()
  17. fs.readFile(filePath,encoding,(err,data)=>{
  18. if(err) dfd.reject(err)
  19. dfd.resolve(data)
  20. })
  21. return dfd.promise
  22. }
  23. read('./1.txt','utf8').then((data)=>{
  24. console.log(data)
  25. })

五、promise的链式调用

promise的核心在于:链式调用。

promise主要解决两个问题:

(1)回调地狱

(2)并发的异步IO操作,同一时间内把这个结果拿到,比如有两个异步io操作,当这2个获取完毕后,才执行相应的代码

1、回调地狱怎么解决

那么我们来看下面的代码,并且改为promise。

  1. // 回调函数
  2. let fs = require('fs')
  3. fs.readFile('./a.txt','utf8',(err,data)=>{ // 往fs.readFile方法传递了第三个为函数的参数
  4. if(err){
  5. console.log(err)
  6. return
  7. }
  8. console.log(data)
  9. })
  10. // 改写为Promise
  11. let fs = require('fs')
  12. function read(filePath,encoding){
  13. return new Promise((resolve,reject)=>{
  14. fs.readFile(filePath,encoding,(err,data)=>{
  15. if(err) reject(err)
  16. resolve()
  17. })
  18. })
  19. }
  20. read('./a.txt','utf8').then((data)=>{ // 在这里则不再需要传回调函数进去,而是采用then来达到链式调用
  21. console.log(data)
  22. },(err)=>{
  23. console.log(err)
  24. })

这样看好像Promise也没什么优势,那么接下来我们对比一下

  1. // 假设有3个文件
  2. // - 1.txt 文本内容为'2.txt'
  3. // - 2.txt 文本内容为'3.txt'
  4. // - 3.txt 文本内容为'hello swr'
  5. // 用回调函数
  6. fs.readFile('./1.txt','utf8',(err,data)=>{
  7. fs.readFile(data,'utf8',(err,data)=>{
  8. fs.readFile(data,'utf8',(err,data)=>{
  9. console.log(data) // hello swr
  10. })
  11. })
  12. })
  13. // 用Promise
  14. read('./1.txt','utf8')
  15. .then((data)=>{
  16. // 1.如果一个promise执行完后,返回的还是一个promise,
  17. // 会把这个promise的执行结果会传递给下一次then中
  18. return read(data,'utf8')
  19. })
  20. .then((data)=>{
  21. return read(data,'utf8')
  22. })
  23. .then((data)=>{
  24. // 2.如果在then中返回的不是一个promise,
  25. // 而是一个普通值,会将这个普通值作为下次then的成功的结果
  26. return data.split('').reverse().join('')
  27. })
  28. .then((data)=>{
  29. console.log(data) // rws olleh
  30. // 3.如果当前then中失败了,会走下一个then的失败回调
  31. throw new Error('出错')
  32. })
  33. .then(null,(err)=>{
  34. console.log(err) // Error:出错 报错了
  35. // 4.如果在then中不返回值,虽然没有显式返回,
  36. // 但是默认是返回undefined,是属于普通值,依然会把这个普通值传到
  37. // 下一个then的成功回调中
  38. })
  39. .then((data)=>{
  40. console.log(data) // undefined
  41. })

从上面可以看得出,改写为Promise的代码,更好阅读和维护,从用Promise方式可以得出结论:

(1)如果一个promise执行完后,返回的是一个promise,会将这个promise的执行结果传递给下一个then回调成功中;

(2)如果在then中返回的不是一个promise,而是一个普通的值,会将这个普通的值传到下一个then成功回调中;

(3)如果当时then中失败了,会走下一个then的回调失败;

(4)如果then不返回值,但是默认是返回undefined的,属于普通值,会将这个普通值传到下一个then成功回调中。

如果在then中抛出错误,会怎么样呢?

情况1:会被下一个then中的失败回调捕获

  1. // 情景一,会被下一个then中的失败回调捕获
  2. read('./1.txt','utf8')
  3. .then((data)=>{
  4. throw new Error('出错了')
  5. })
  6. .then(null,(err)=>{
  7. console.log(err) // Error:出错了 报错
  8. })

情况2:没有被失败回调捕获,抛出错误最终会变成异常

  1. read('./1.txt','utf8')
  2. .then((data)=>{
  3. throw new Error('出错了')
  4. })

情况3:如果没有被失败的回调捕获,那么最终会被catch捕获到

  1. read('./1.txt','utf8')
  2. .then((data)=>{
  3. throw new Error('出错了')
  4. })
  5. .then((data)=>{
  6. })
  7. .catch((err)=>{
  8. console.log(err) // Error:出错了 报错
  9. })

情况4:如果被失败的回调捕获,那么就不会被catch捕获到

  1. read('./1.txt','utf8')
  2. .then((data)=>{
  3. throw new Error('出错了')
  4. })
  5. .then(null,(err)=>{
  6. console.log(err) // Error:出错了 报错
  7. })
  8. .catch((err)=>{
  9. console.log(err) // 不会执行到这里
  10. })

(5)catch是错误没有处理的情况下才会执行

(6)then回调中可以不写

六、关于promise的其他问题

1、性能问题

可能各位看官会觉得奇怪,Promise能有什么性能问题呢?并没有大量的计算啊,几乎都是处理逻辑的代码。

理论上说,不能叫做“性能问题”,而只是有可能出现的延迟问题。什么意思呢,记得刚刚我们说需要把4块代码包在setTimeout里吧,先考虑如下代码:

  1. var start = +new Date()
  2. function foo() {
  3. setTimeout(function() {
  4. console.log('setTimeout')
  5. if((+new Date) - start < 1000) {
  6. foo()
  7. }
  8. })
  9. }
  10. foo()

运行上面的代码,会打印出多少次'setTimeout'呢,各位可以自己试一下,不出意外的话,应该是250次左右,我刚刚运行了一次,是241次。这说明,上述代码中两次setTimeout运行的时间间隔约是4ms(另外,setInterval也是一样的),实事上,这正是浏览器两次Event Loop之间的时间间隔,相关标准各位可以自行查阅。另外,在Node中,这个时间间隔跟浏览器不一样,经过我的测试,是1ms。

单单一个4ms的延迟可能在一般的web应用中并不会有什么问题,但是考虑极端情况,我们有20个Promise链式调用,加上代码运行的时间,那么这个链式调用的第一行代码跟最后一行代码的运行很可能会超过100ms,如果这之间没有对UI有任何更新的话,虽然本质上没有什么性能问题,但可能会造成一定的卡顿或者闪烁,虽然在web应用中这种情形并不常见,但是在Node应用中,确实是有可能出现这样的case的,所以一个能够应用于生产环境的实现有必要把这个延迟消除掉。在Node中,我们可以调用process.nextTick或者setImmediate(Q就是这么做的),在浏览器中具体如何做,已经超出了本文的讨论范围,总的来说,就是我们需要实现一个函数,行为跟setTimeout一样,但它需要异步且尽早的调用所有已经加入队列的函数,这里有一个实现。

2、如何停止一个promise链?

在一些场景里,我们会遇到一个较长的promise的链式调用,在某一步出现的错误让我们没有必要去运行链式调用后面所有的代码,类似于下面这样的(此处省略then/catch里的函数):

  1. new Promise(function(resolve, reject) {
  2. resolve(42)
  3. })
  4. .then(function(value) {
  5. // "Big ERROR!!!"
  6. })
  7. .catch()
  8. .then()
  9. .then()
  10. .catch()
  11. .then()

假设这个`Big ERROR!!!`的出现让我们完全没有必要运行后面所有的代码了,但链式调用的后面即有catch,也有then,无论我们是`return`还是`throw`,都不可避免的会进入某一个`catch`或`then`里面,那有没有办法让这个链式调用在`Big ERROR!!!`的后面就停掉,完全不去执行链式调用后面所有回调函数呢?

从一个实现者的角度看问题时,确实找到了答案,就是在发生`Big ERROR`后return一个Promise,但这个Promise的executor函数什么也不做,这就意味着这个Promise将永远处于`pending`状态,由于then返回的Promise会直接取这个永远处于`pending`状态的Promise的状态,于是返回的这个Promise也将一直处于`pending`状态,后面的代码也就一直不会执行了,具体代码如下:

  1. new Promise(function(resolve, reject) {
  2. resolve(42)
  3. })
  4. .then(function(value) {
  5. // "Big ERROR!!!"
  6. return new Promise(function(){})
  7. })
  8. .catch()
  9. .then()
  10. .then()
  11. .catch()
  12. .then()

这种方式看起来有些山寨,它也确实解决了问题。但它引入的一个新问题就是链式调用后面的所有回调函数都无法被垃圾回收器回收(在一个靠谱的实现里,Promise应该在执行完所有回调后删除对所有回调函数的引用以让它们能被回收,在前文的实现里,为了减少复杂度,并没有做这种处理),但如果我们不使用匿名函数,而是使用函数定义或者函数变量的话,在需要多次执行的Promise链中,这些函数也都只有一份在内存中,不被回收也是可以接受的。

将返回一个什么也不做的Promise封装成一个有语义的函数,以增加代码的可读性

  1. Promise.cancel = Promise.stop = function() {
  2. return new Promise(function(){})
  3. }

这么使用了:

  1. new Promise(function(resolve, reject) {
  2. resolve(42)
  3. })
  4. .then(function(value) {
  5. // "Big ERROR!!!"
  6. return Promise.stop()
  7. })
  8. .catch()
  9. .then()
  10. .then()
  11. .catch()
  12. .then()

3、promise的链上返回的最后一个promise出错了怎么办?

  1. new Promise(function(resolve) {
  2. resolve(42)
  3. })
  4. .then(function(value) {
  5. alter(value)
  6. })

但运行这段代码的话你会发现什么现象也不会发生,既不会alert出42,也不会在控制台报错,怎么回事呢。细看最后一行,`alert`被打成了`alter`,那为什么控制台也没有报错呢,因为`alter`所在的函数是被包在`try/catch`块里的,`alter`这个变量找不到就直接抛错了,这个错就正好成了then返回的Promise的rejection reason。

解决办法:

(1)所有的promise链的最后都加上一个catch,这样出错后就会被捕获到,这样违背了DRY原则,而且繁琐;

(2)借鉴Q的一个方法done,把这个方法加到promise链的最后,就能够处理捕获最后一个promise出现的错误,其实个catch的思路一样,这个是框架来实现的。

(3)在一个Promise被reject的时候检查这个Promise的onRejectedCallback数组,如果它为空,则说明它的错误将没有函数处理,这个时候,我们需要把错误输出到控制台,让开发者可以发现。

在Promise被reject但又没有callback时,把错误输出到控制台。

4、出错时,使用throw new Error()还是使用return Promise.reject(new Error())呢?

从性能和编码的舒适角度考虑:

(1)性能方面:throw new Error()会使代码进入catch块里的逻辑(我们把多有的回调都包在try/catch里),传说throw多了会影响性能,因为一旦throw,代码就有可能跳转到不可预知的位置。

而使用promise.reject(new Error()),则需要构造一个新的promise对象(包含2个数组,4个函数:resolve/reject,onResolved/onRejected),也会花费一定的时间和内存。因为onResolved/onRejected函数是直接被包在promise实现里的try里,出错后直接进入到这个try对应的catch块,代码的跳跃幅度相对较小,性能应该可以忽略不记。

(2)编码的舒适度方面:出错用throw,正常用return,正常可以明显的区分出错和正常

综上觉得还是promise里发现显式错误后,用throw抛出错误比较好,而不是显式的构造一个呗reject的promise对象。

 

七、实践

注意:

1、不要把promise写成嵌套的结构

  1. // 错误的写法
  2. promise1.then(function(value) {
  3. promise1.then(function(value) {
  4. promise1.then(function(value) {
  5. })
  6. })
  7. })

2、链式promise要返回一个promise,而不是构造一个promise

  1. // 错误的写法
  2. Promise.resolve(1).then(function(){
  3. Promise.resolve(2)
  4. }).then(function(){
  5. Promise.resolve(3)
  6. })

 

八、参考

https://github.com/xieranmaya/blog/issues/3

ES6--浅析Promise内部结构的更多相关文章

  1. ES6的promise对象研究

    ES6的promise对象研究 什么叫promise? Promise对象可以理解为一次执行的异步操作,使用promise对象之后可以使用一种链式调用的方式来组织代码:让代码更加的直观. 那我们为什么 ...

  2. ES6的Promise

    推荐一下我觉得不错关于Promise的好文章,通俗易懂 说起ES6的Promise就要提及一下JQ的$.when()方法,两者基本相同 面试的时候经常会问Promise,如果同学们能在回答Promis ...

  3. ES6语法 promise用法

    ES6语法 promise用法 function doSomething(){ return new Promise((resolve,reject)=>{ resolve('jjjj');// ...

  4. 浅谈ES6原生Promise

    浅谈ES6原生Promise 转载 作者:samchowgo 链接:https://segmentfault.com/a/1190000006708151 ES6标准出炉之前,一个幽灵,回调的幽灵,游 ...

  5. ES6之Promise用法详解

    一 前言 本文主要对ES6的Promise进行一些入门级的介绍.要想学习一个知识点,肯定是从三个方面出发,what.why.how.下面就跟着我一步步学习吧~ 二 什么是Promise 首先是what ...

  6. ES6中promise总结

    一.什么是ES6的Promise 讲太多也没有.直接在打印出来就好,console.dir(Promise) Promise 是一个构造函数,自身有all, reject, resolve 这几个眼熟 ...

  7. ES6新增"Promise"可避免回调地狱

    Promise是一个构造函数,自己身上有all.reject.resolve这几个眼熟的方法,原型上有then.catch等同样很眼熟的方法. 那就new一个 var p = new Promise( ...

  8. 关于ES6的Promise的使用深入理解

    ES6的promise对象研究 什么叫promise? Promise对象可以理解为一次执行的异步操作,使用promise对象之后可以使用一种链式调用的方式来组织代码:让代码更加的直观. 那我们为什么 ...

  9. 剖析Promise内部结构,一步一步实现一个完整的、能通过所有Test case的Promise类

    本文写给有一定Promise使用经验的人,如果你还没有使用过Promise,这篇文章可能不适合你,建议先了解Promise的使用 Promise标准解读 1.只有一个then方法,没有catch,ra ...

随机推荐

  1. uedit,检测粘贴事件,替换粘贴内容

    vue.editor.addListener("beforepaste",function(type, arg1, arg2){arg1.html="ddddddd&qu ...

  2. 数据准备<3>:数据预处理

    数据预处理是指因为算法或者分析需要,对经过数据质量检查后的数据进行转换.衍生.规约等操作的过程.整个数据预处理工作主要包括五个方面内容:简单函数变换.标准化.衍生虚拟变量.离散化.降维.本文将作展开介 ...

  3. 前端工程化(二)---webpack配置

    导航 前端工程化(一)---工程基础目录搭建 前端工程化(二)---webpack配置 前端工程化(三)---Vue的开发模式 前端工程化(四)---helloWord 继续上一遍的配置,本节主要记录 ...

  4. java.IO层次体系结构

    在整个Java.io包中最重要的就是5个类和一个接口.5个类指的是File.OutputStream.InputStream.Writer.Reader:一个接口指的是Serializable.掌握了 ...

  5. String的charAt(int index)可用于遍历一个字符串的所有字符

    charAt(int index)遍历一个字符串的所有字符实例 String name = "Whatisjava?"; for (int i = 0; i < name.l ...

  6. .net关于坐标之间一些简单操作

    火星坐标系 (GCJ-02)转换为百度坐标系 (BD-09) function GCJ02toBD09(lng, lat) { var x_pi = 3.14159265358979324 * 300 ...

  7. SpringBootApplication注解 专题

    到这里,看到所有的配置是借助SpringFactoriesLoader加载了META-INF/spring.factories文件里面所有符合条件的配置项的全路径名.找到spring-boot-aut ...

  8. 分布式服务跟踪及Spring Cloud的实现

    在分布式服务架构中,需要对分布式服务进行治理——在分布式服务协同向用户提供服务时,每个请求都被哪些服务处理?在遇到问题时,在调用哪个服务上发生了问题?在分析性能时,调用各个服务都花了多长时间?哪些调用 ...

  9. 再谈DOMContentLoaded与渲染阻塞—分析html页面事件与资源加载

    浏览器的多线程中,有的线程负责加载资源,有的线程负责执行脚本,有的线程负责渲染界面,有的线程负责轮询.监听用户事件. 这些线程,根据浏览器自身特点以及web标准等等,有的会被浏览器特意的阻塞.两个很明 ...

  10. python 简单的信息管理系统

    #!/usr/bin/python #coding=utf-8 import io import os import time FileRead = io.open('callingcard','r' ...