Promise的一些问题

一、Promise的状态

pending、resolved（fulfilled）、rejected
状态一旦改变，就无法再次改变状态。

二、Promise如何解决地狱回调

then里面可以return Promise，来防止地狱回调

function request1() {
	return new Promise(resolve => resolve(1));
}
function request2() {
	return new Promise(resolve => resolve(2));
}
function request3() {
	return new Promise(resolve => resolve(3));
}

request1().then(v => {
	console.log('第一层then')；
	return request2();
})
.then(v => {
	console.log('第二层then')；
	return request3();
})

不使用return的话：
request1().then(v => {
	console.log('第一层then')；
	request2().then(v => {
		request3()
	})
})

三、Promise有哪些方法？应用场景？

Promise的原型上有then和catch两个方法。

Promise.resolve() 和 Promise.reject() 用于创建一个立即成功或者立即失败的promise。

1. Promise.all()

接收一个Promise的iterable类型（可迭代类型，包括array，Map，Set），返回一个Promise实例。
resolve回调是在所有输入的Promise的resolve回调之后执行
reject回调则是只要有一个输入的Promise的reject回调执行，它就会执行

const promise1 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(1);
	}, 3000);
})
const promise2 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(2);
	}, 2000);
})
const promise3 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(3);
	}, 1000);
})
Promise.all([promise1, promise2, promise3]).then(res => {
	console.log(res); //  [1, 2, 3]
})

当有一个输入Promise reject后，整体就进入catch回调，不会进入then回调

const promise1 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(1);
	}, 3000);
})
const promise2 = new Promise((resolve, reject) => {
	setTimeout(() => {
		reject(2);
	}, 2000);
})
const promise3 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(3);
	}, 1000);
})
Promise.all([promise1, promise2, promise3]).then(res => {
	console.log(res); 
})
.catch(err => {
	console.log(err); // 2
})

如果希望Promise.all()返回的实例在其中一个输入promise reject的时候依然可以进入then回调，则需要为每一个有可能reject的promise手动catch

const promise1 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(1);
	}, 3000);
});
const promise2 = new Promise((resolve, reject) => {
	setTimeout(() => {
		reject(2);
	}, 2000);
}).catch(err => {
	console.log(err);  // 2
});
const promise3 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(3);
	}, 1000);
});
Promise.all([promise1, promise2, promise3]).then(res => {
	console.log(res); 
})
.catch(err => {
	console.log(err);  // [1, undefined, 3]
})

2. Promise.allSettled()

返回一个在所有的输入promise都已经fufilled或者rejected后的promise，并带有一个对象数组，每个对象包含promise的结果。

Promise.allSettled(promises)可以并行地运行 promise，并将状态（fulfilled 或reject）收集到一个聚合数组中。

Promise.allSettled()在你需要执行平行和独立的异步操作并收集所有结果时非常有效，即使某些异步操作可能失败。

Promise.all()适合多个异步操作之间相互依赖的场景。

const promise1 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(1);
	}, 3000);
});
const promise2 = new Promise((resolve, reject) => {
	setTimeout(() => {
		reject(2);
	}, 2000);
});
const promise3 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(3);
	}, 1000);
});
Promise.allSettled([promise1, promise2, promise3]).then(res => {
	console.log(res);  //  [{status: 'fulfilled', value: 1}, {status: 'rejected', reason: 2},{status: 'fulfilled', value: 3}]
})
.catch(err => {
	console.log(err); 
})

3. Promise.any()

接收一个promise可迭代对象，但只要一个promise成功，就返回那个已经成功的promise。用于返回第一个成功的promise。

const promise1 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(1);
	}, 3000);
});
const promise2 = new Promise((resolve, reject) => {
	setTimeout(() => {
		reject(2);
	}, 2000);
});
const promise3 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(3);
	}, 1000);
});
Promise.any([promise1, promise2, promise3]).then(res => {
	console.log(res);  // 3
})
.catch(err => {
	console.log(err); 
})

4. Promise.race()

接受一个promise可迭代对象，只要输入的promise中有一个promise resolve或者reject，返回的promise就会是resolve或者reject。

const promise1 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(1);
	}, 3000);
});
const promise2 = new Promise((resolve, reject) => {
	setTimeout(() => {
		reject(2);
	}, 0);
});
const promise3 = new Promise((resolve, reject) => {
	setTimeout(() => {
		resolve(3);
	}, 1000);
});
Promise.race([promise1, promise2, promise3]).then(res => {
	console.log(res); 
})
.catch(err => {
	console.log(err);  // 2
})

• 多个异步并行，且相互有依赖，使用Promise.all()
• 多个异步并行，且相互并行，使用Promise.allSettled()
• 多个异步并行，最终结果根据第一个结果（不论成功还是失败）的promise而定，使用Promise.race()
• 多个异步并行，最终结果根据第一个成功的promise而定，使用Promise.any()

四、如何让Promise顺序执行？

async/await