版权声明:转载请注明出处 https://blog.csdn.net/weixin_43586120/article/details/88233336
Promise的回调函数不是正常的异步任务,而是微任务(microtask)。区别在于,正常异步任务追加到下一轮事件循环,微任务追加到本轮事件循环。js中的代码执行顺序为:同步程序——promise微任务——异步程序。
//例子1:
let promise = new Promise(function(resolve,reject){
console.log('Promise');
resolve();
});
promise.then(function(){
console.log('resolved');
});
console.log('Hi!'); //Promise Hi! resolved
例子2:
setTimeout(function() {
console.log(1)
}, 0);
new Promise(function executor(resolve) {
console.log(2);
for( var i=0 ; i<10000 ; i++ ) {
i == 9999 && resolve();
}
console.log(3);
}).then(function() {
console.log(4);
});
console.log(5); //2 3 5 4 1
// Promise的回调函数不是正常的异步任务,而是微任务(microtask)。区别在于,正常异步任务追加到
//下一轮事件循环,微任务追加到本轮事件循环。这意味着,微任务的执行时间一定早于正常异步任务。then的
//回调函数的执行时间,早于setTimeout(fn, 0)。因为then是本轮事件循环执行,setTimeout(fn, 0)在
//下一轮事件循环开始时执行
//例子3:
const promise = new Promise((resolve, reject) => {
console.log(1)
resolve()
console.log(2)
})
promise.then(() => {
console.log(3)
})
console.log(4) //1 2 4 3
//例子4:
const promise1 = new Promise((resolve, reject) => {
setTimeout(() => {
resolve('success')
}, 1000)
})
const promise2 = promise1.then(() => {
//上面 promise2 并不是 promise1,而是返回的一个新的 Promise 实例
throw new Error('error!!!')
})
console.log('promise1', promise1)
console.log('promise2', promise2)
setTimeout(() => {
console.log('promise1', promise1)
console.log('promise2', promise2)
}, 2000)
//promise1 Promise {<pending>}
//promise2 Promise {<pending>}
// Uncaught (in promise) Error: error!!! at promise1.then (<anonymous>:7:8)
//promise1 Promise {<resolved>: "success"}
//promise2 Promise {<rejected>: Error: error!!! at promise1.then (<anonymous>:7:8)}
//例子5:
const promise = new Promise((resolve, reject) => {
resolve('success1')
reject('error')
resolve('success2')
})
promise
.then((res) => {
console.log('then: ', res)
})
.catch((err) => {
console.log('catch: ', err)
}) //then:success1
//例子6:
Promise.resolve(1)
.then((res) => {
console.log(res)
return 2;
})
.catch((err) => {
return 3;
})
.then((res) => {
console.log(res);
}) //1 2
//promise 每次调用 .then 或者 .catch 都会返回一个新的 promise,从而实现了链式调用
//例子7:
const promise = new Promise((resolve, reject) => {
setTimeout(() => {
console.log('once')
resolve('success')
}, 1000)
})
const start = Date.now();
promise.then((res) => {
console.log(res, Date.now() - start)
})
promise.then((res) => {
console.log(res, Date.now() - start)
})
//once
//promise 的 .then 或者 .catch 可以被调用多次,但这里 Promise 构造函数只执行一次,或者说 promise 内部状态一经改变,并且有了一个值,那么后续每次调用 .then 或者 .catch 都会直接拿到该值
//success 991
//success 991(时间不定)
//例子8:
Promise.resolve()
.then(() => {
return new Error('error!!!')
})
.then((res) => {
console.log('then: ', res)
})
.catch((err) => {
console.log('catch: ', err)
})
// then: Error: error!!! at Promise.resolve.then (<anonymous>:3:8)
// .then 或者 .catch 中 return 一个 error 对象并不会抛出错误,所以不会被后续的 .catch 捕获,需要改成其中一种:
//return Promise.reject(new Error('error!!!')) || throw new Error('error!!!')
//因为返回任意一个非 promise 的值都会被包裹成 promise 对象,即 return new Error(‘error!!!’) 等价于 return Promise.resolve(new Error(‘error!!!’))
//例子9:
Promise.resolve(1)
.then(2)
.then(Promise.resolve(3))
.then(console.log) //1
//.then 或者 .catch 的参数期望是函数,传入非函数则会发生值穿透