转载：许诺输出题10种加强理解的方法。
1.
常量承诺=新承诺((解决，拒绝)=}
console . log(1)；
resolve()；
console . log(2)；
})
promise.then(()={)
console . log(3)；
})
console . log(4)；
回答
遇到Promise后立即执行，输出1，2。
执行同步代码，输出4。
执行promise.then()中的代码，并输出3。
2.
console.log('脚本开始')；
setTimeout(函数(){ 0
console . log(' setTimeout ')；
},0);
新承诺(功能(解析){ 0
console . log(' promise 1 ')；
resolve()；
console . log(' promise 2 ')；
}).然后(函数(){ 0
console . log(' promise then ')；
});
console.log('脚本结束')；
回答
脚本开始
承诺1
承诺2
脚本结束
那么答应我
定时器
首先，JavaScript引擎将执行一个宏任务。注意，这个宏任务一般是指骨干代码本身，也就是当前的同步代码。
如果在执行过程中遇到微任务，它将被添加到微任务队列中。
宏任务执行后，立即执行当前微任务队列中的微任务，直到微任务队列清空。
微任务执行完成后，开始执行下一个宏任务。
这样重复，直到宏任务和微任务被清空。
3.
常量承诺=新承诺((解决，拒绝)=}
解析(“成功1”)；
拒绝('错误')；
解析(“成功2”)；
});
promise .然后((RES)=}
console.log('then: '，RES)；
}).catch((err)={ 0
console.log('catch: '，err)；
})
回答
然后：成功1
本文研究了承诺单向传递的特征，承诺有三种状态：
悬而未决的
断然的
拒绝
这三种状态的转换只能是待定-解决或待定-拒绝。不会有解决-拒绝或待定-解决-拒绝等。也就是说，状态只能从挂起状态向一个方向转移，并且只能更改一次。
在promise中，resolve()将更改promise的状态，以便在resolve成功时调用，并且先出现已解决的状态。然后(' success1')={console.log('然后是： '，' success 1 ')；})
承诺状态一旦改变，就不能修改，所以。catch()和第二次解析(“success2”)将不会执行。
4.
承诺.决心(1)。然后(2)。然后(承诺.决心(3))。然后(console.log)
回答
一个
中的参数。那么()必须是一个函数。如果是非函数，就会发生价值渗透，最后是第三种。然后将执行()函数，参数为1。
5.
承诺.决心(1)。然后((RES)=}
console.log(res)
返回2
})。catch((err)={ 0
返回3
})。然后((RES)=}
console.log(res)
})
回答
一个
2
Promise.resolve()返回一个新的承诺，并执行第一个。然后()用参数1。
打印1，返回返回带有参数2的新承诺。
执行第二个。然后用参数2()并键入。
印出 2
6.
Promise.resolve()
.then(() = {
return new Error('error!!!')
})
.then((res) = {
console.log('then: ', res)
})
.catch((err) = {
console.log('catch: ', err)
})
答案
then: Error: error!!!
这里的陷阱在于只有抛出错误时才会执行 .catch()，题目中并不是抛出错误，所以执行 .then()。
改成如下方式会执行 .catch():
return Promise.reject(new Error('error!!!'))
throw new Error('error!!!')
7.
const promise = Promise.resolve()
.then(() = {
return promise
})
promise.catch(console.error)
答案
TypeError: Chaining cycle detected for promise #Promise
.then()或.catch()返回的值不能是 promise 本身，否则会造成死循环。
8.
setTimeout(() = {
console.log(1)
Promise.resolve(3).then(data = console.log(data))
}, 0)
setTimeout(() = {
console.log(2)
}, 0)
答案
1 3 2
先执行整体代码，没有发现微任务；
再执行下一个宏任务—setTimeout回调函数，打印出1；
遇到微任务—Promise 回调函数；
立即执行微任务，打印出3；
微任务队列被清空，执行下一个宏任务—下一个setTimeout回调函数，打印出2。
这道题有点不一样的是，Promise 回调这个微任务，是在 setTimeout 回调这个宏任务中，被触发的。不过无论怎样，它们都遵循 Event Loop 的模型规则。
9.
var pro = new Promise((res,rej)={
res(1);
});
pro.then(res={
console.log(res);
});
setTimeout(()={
console.log(2);
})
pro.then(res={
console.log(res);
})
答案
1 1 2
promise 对象赋值给了变量 pro，每个.then()都是独立的。
10.
async function async1 () {
console.log('async1 start');
await async2();
console.log('async1 end');
}
async function async2 () {
console.log('async2');
}
console.log('script start');
setTimeout(function () {
console.log('setTimeout');
}, 0);
async1()
new Promise (function (resolve) {
console.log('promise1');
resolve();
}).then (function () {
console.log('promise2');
})
console.log('script end');
答案
script start async1 start async2 promise1 script end async1 end promise2 setTimeout
定义 async1()，async2()，不会立即执行
await async2(); 表示先执行 async2()，然后将 await 后面的代码当作 .then() 中的回调来处理
初始化 promise，promise 中的代码会立即执行
总结
基本上所有与异步相关的问题都可以用 event loop 来解释。最后，我们再来回顾一遍 event loop 的执行规则：
首先执行宏任务，这个宏任务一般指 主干代码，我们经常称之为同步代码；
执行过程中如果遇到了微任务，将其加入到微任务队列中；
执行完宏任务之后，开始执行微任务队列中的任务，直至微任务队列为空；
微任务执行完之后，开始执行下一个宏任务；
如何循环执行，直到宏任务和微任务都执行完。
作者：腐烂的橘子
链接：https://leetcode-cn.com/circle/discuss/sQXY3u/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
内容来源网络，如有侵权，联系删除，本文地址：https://www.230890.com/zhan/37474.html