ES6之Promise常见面试题

ES6

• 谈一谈 promise
• 所有的 ES6 特性你都知道吗？如果遇到一个东西不知道是 ES6 还是 ES5, 你该怎么区分它
• es6的继承和es5的继承有什么区别
• promise封装ajax
• let const的优点
• es6 generator 是什么，async/await 实现原理
• ES6和node的commonjs模块化规范区别
• 箭头函数，以及它的this

 

Promise 想必大家都十分熟悉，想想就那么几个 api，可是你真的了解 Promise 吗？本文根据 Promise 的一些知识点总结了十道题，看看你能做对几道。

以下 promise 均指代 Promise 实例，环境是 Node.js。

题目一

1. const promise = new Promise((resolve, reject) => {

2. console.log(1)

3. resolve()

4. console.log(2)

5. })

6. promise.then(() => {

7. console.log(3)

8. })

9. console.log(4)

运行结果：

1. 1

2. 2

3. 4

4. 3

解释：Promise 构造函数是同步执行的，promise.then 中的函数是异步执行的。

题目二

1. const promise1 = new Promise((resolve, reject) => {

2. setTimeout(() => {

3. resolve('success')

4. }, 1000)

5. })

6. const promise2 = promise1.then(() => {

7. throw new Error('error!!!')

8. })

9.  

10. console.log('promise1', promise1)

11. console.log('promise2', promise2)

12.  

13. setTimeout(() => {

14. console.log('promise1', promise1)

15. console.log('promise2', promise2)

16. }, 2000)

运行结果：

1. promise1 Promise { <pending> }

2. promise2 Promise { <pending> }

3. (node:50928) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 1): Error: error!!!

4. (node:50928) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

5. promise1 Promise { 'success' }

6. promise2 Promise {

7. <rejected> Error: error!!!

8. at promise.then (...)

9. at <anonymous> }

解释：promise 有 3 种状态：pending、fulfilled 或 rejected。状态改变只能是 pending->fulfilled 或者 pending->rejected，状态一旦改变则不能再变。上面 promise2 并不是 promise1，而是返回的一个新的 Promise 实例。

题目三

1. const promise = new Promise((resolve, reject) => {

2. resolve('success1')

3. reject('error')

4. resolve('success2')

5. })

6.  

7. promise

8. .then((res) => {

9. console.log('then: ', res)

10. })

11. .catch((err) => {

12. console.log('catch: ', err)

13. })

运行结果：

then: success1

解释：构造函数中的 resolve 或 reject 只有第一次执行有效，多次调用没有任何作用，呼应代码二结论：promise 状态一旦改变则不能再变。

题目四

1. Promise.resolve(1)

2. .then((res) => {

3. console.log(res)

4. return 2

5. })

6. .catch((err) => {

7. return 3

8. })

9. .then((res) => {

10. console.log(res)

11. })

运行结果：

1. 1

2. 2

解释：promise 可以链式调用。提起链式调用我们通常会想到通过 return this 实现，不过 Promise 并不是这样实现的。promise 每次调用 .then 或者 .catch 都会返回一个新的 promise，从而实现了链式调用。

题目五

1. const promise = new Promise((resolve, reject) => {

2. setTimeout(() => {

3. console.log('once')

4. resolve('success')

5. }, 1000)

6. })

7.  

8. const start = Date.now()

9. promise.then((res) => {

10. console.log(res, Date.now() - start)

11. })

12. promise.then((res) => {

13. console.log(res, Date.now() - start)

14. })

运行结果：

1. once

2. success 1005

3. success 1007

解释：promise 的 .then 或者 .catch 可以被调用多次，但这里 Promise 构造函数只执行一次。或者说 promise 内部状态一经改变，并且有了一个值，那么后续每次调用 .then 或者 .catch 都会直接拿到该值。

题目六

1. Promise.resolve()

2. .then(() => {

3. return new Error('error!!!')

4. })

5. .then((res) => {

6. console.log('then: ', res)

7. })

8. .catch((err) => {

9. console.log('catch: ', err)

10. })

运行结果：

1. then: Error: error!!!

2. at Promise.resolve.then (...)

3. at ...

解释：.then 或者 .catch 中 return 一个 error 对象并不会抛出错误，所以不会被后续的 .catch 捕获，需要改成其中一种：

1. return Promise.reject(new Error('error!!!'))

2. throw new Error('error!!!')

因为返回任意一个非 promise 的值都会被包裹成 promise 对象，即 return new Error('error!!!') 等价于 return Promise.resolve(new Error('error!!!'))。

题目七

1. const promise = Promise.resolve()

2. .then(() => {

3. return promise

4. })

5. promise.catch(console.error)

运行结果：

1. TypeError: Chaining cycle detected for promise #<Promise>

2. at <anonymous>

3. at process._tickCallback (internal/process/next_tick.js:188:7)

4. at Function.Module.runMain (module.js:667:11)

5. at startup (bootstrap_node.js:187:16)

6. at bootstrap_node.js:607:3

解释：.then 或 .catch 返回的值不能是 promise 本身，否则会造成死循环。类似于：

1. process.nextTick(function tick () {

2. console.log('tick')

3. process.nextTick(tick)

4. })

题目八

1. Promise.resolve(1)

2. .then(2)

3. .then(Promise.resolve(3))

4. .then(console.log)

运行结果：

1

 

解释：.then 或者 .catch 的参数期望是函数，传入非函数则会发生值穿透。

题目九

1. Promise.resolve()

2. .then(function success (res) {

3. throw new Error('error')

4. }, function fail1 (e) {

5. console.error('fail1: ', e)

6. })

7. .catch(function fail2 (e) {

8. console.error('fail2: ', e)

9. })

运行结果：

1. fail2: Error: error

2. at success (...)

3. at ...

解释：.then 可以接收两个参数，第一个是处理成功的函数，第二个是处理错误的函数。.catch 是 .then 第二个参数的简便写法，但是它们用法上有一点需要注意：.then 的第二个处理错误的函数捕获不了第一个处理成功的函数抛出的错误，而后续的 .catch 可以捕获之前的错误。当然以下代码也可以：

1. Promise.resolve()

2. .then(function success1 (res) {

3. throw new Error('error')

4. }, function fail1 (e) {

5. console.error('fail1: ', e)

6. })

7. .then(function success2 (res) {

8. }, function fail2 (e) {

9. console.error('fail2: ', e)

10. })

题目十

1. process.nextTick(() => {

2. console.log('nextTick')

3. })

4. Promise.resolve()

5. .then(() => {

6. console.log('then')

7. })

8. setImmediate(() => {

9. console.log('setImmediate')

10. })

11. console.log('end')

运行结果：

1. end

2. nextTick

3. then

4. setImmediate

解释：process.nextTick 和 promise.then 都属于 microtask，而 setImmediate 属于 macrotask，在事件循环的 check 阶段执行。事件循环的每个阶段（macrotask）之间都会执行 microtask，事件循环的开始会先执行一次 microtask。