**1. `Promise.resolve(obj)`函数**
* 如果 obj 是非 Promise 对象，则将其转换为 Promise 对象。
* 如果 obj 本身就是一个 Promise 对象，则原封不动地返回该 obj。
* 该方法封装的 Promise 对象的状态为 fulfilled（已成功）。
```js
// 非Promise对象
const p01 = Promise.resolve('p01')
// Promise对象
const p02 = Promise.resolve(new Promise((resolve, reject) => {
resolve('p02')
}))
p01.then(value => {
console.info(value) //p01
})
p02.then(value => {
console.info(value) //p02
})
```
<br/>
**2. `Promise.reject(obj)`函数**
* 与`Promise.resolve(obj)`是一样的功能，不过该方法封装的 Promise 对象的状态为 rejected（已失败）。
```js
//非Promise对象
const p01 = Promise.reject('p01')
//Promise对象
const p02 = Promise.reject(
new Promise((resolve, reject) => {
resolve('resolve -> p02')
})
)
p01
.then((value) => {
console.info(value) //这里没有被调用
})
.catch((reason) => {
console.error(reason) //p01
})
p02
.then((value) => {
console.info(value) //这里没有被调用
})
.catch((reason) => {
reason.then((value) => {
console.info(value) //resolve -> p02
})
})
```
<br/>
**3. `Promise.prototype.then`函数的链式调用**
* 会按照顺序依次被调用。
```js
const p = new Promise((resolve,reject) => {
resolve(1)
})
p.then((value) => {
console.log(value) //1
return 2
}).then((value) => {
console.log(value) //2
}).then((value) => {
console.log(value) //undefined
return Promise.resolve(3)
}).then((value) => {
console.log(value) //3
return Promise.reject(4)
}).then((value) => {
console.log(value) //这里不被调用
}, (err) => {
console.log(err) //4
})
```
<br/>
**4. `Promise.prototype.catch`函数捕捉错误**
* `then(value).catch(reason)`其实就是`then(value, reason)`的别名。
```js
const fun01 = (count) => {
return new Promise((resolve, reject) => {
if (count === 1) {
resolve('成功时的回调')
} else {
reject('失败时的回调')
}
})
}
/**
* 捕获异常。
* 可以将函数 then(value, reason) 写成 then(value).catch(reason) 来捕获异常
*/
fun01(3).then((value) => {
console.info('success', value)
})
.catch((reason) => {
console.error('fail', reason) //fail 失败时的回调
})
/**
* Promise 对象的错误具有"冒泡"性质，会一直向后传递，直到被捕获为止。
* 也就是说，错误总是会被下一个 catch 语句捕获。
*/
fun01(3).then(value => {
console.info('s01', value)
}).then((value) => {
console.info('s02', value)
}).catch(e1 => {
console.error('e01', e1) //e01 失败时的回调
})
```
<br/>
**5. `Promise.all([p1, p2, .p3])`函数**
* `var p = Promise.all([p1,p2,p3]);`
* 可以将多个 Promise 实例封装成一个新的 Promise 实例。
* `[p1, p2, p3]`参数不一定要求是数组，但是参数必须具有 iterator 接口，并且每个成员都必须是Promise 实例。
* 如果 p1 不是 Promise 实例，则交给`Promise.resolve(obj)`将其转换为 Promise 实例。
* 新的 Promise 状态：
* 只有 p1、p2、p3 的状态都变成 fulfilled（已成功），p 的状态才会变成 fulfilled（已成功），此时 p1、p2、p3 的返回值组成一个数组，传递给 p 的回调函数。
* 只要 p1、p2、p3 之中有一个被 rejected（已失败），p 的状态就变成 rejected（已失败），此时第一个被 rejected 实例的返回值，会传递给 p 的回调函数。
```js
const p01 = Promise.resolve('p01')
const p02 = Promise.resolve('p02')
const p03 = Promise.resolve('p03')
//p04为rejected状态
const p04 = Promise.reject('p04')
const newP01 = Promise.all([p01, p02, p03])
const newP02 = Promise.all([p01, p04, p02])
newP01.then(value => {
console.info(value) //['p01', 'p02', 'p03']
})
newP02.then((value, reason) => {
console.info(value)
console.info(reason) //p04
})
```
<br/>
**6. `Promise.race([p1, p2, .p3])`函数**
* `var p = Promise.race([p1,p2,p3]);`
* 与`Promise.all([p1, p2, .p3])`是一样的功能，但是状态的改变方式不同。
* 只要p1、p2、p3之中有一个实例率先改变状态，p 的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给 p 的返回值。
```js
const p01 = Promise.resolve('p01')
const p02 = Promise.resolve('p02')
const p03 = Promise.resolve('p03')
const newP01 = Promise.race([p01, p02, p03])
newP01.then((value) => {
console.info(value) //p01
})
```
- nodejs
- 同时安装多个node版本
- Vue3
- 创建Vue3项目
- 使用 vue-cli 创建
- 使用 vite 创建
- 常用的Composition API
- setup
- ref
- reactive
- 响应数据原理
- setup细节
- reactive与ref细节
- 计算属性与监视
- 生命周期函数
- toRefs
- 其它的Composition API
- shallowReactive与shallowRef
- readonly与shallowReadonly
- toRaw与markRaw
- toRef
- customRef
- provide与inject
- 响应式数据的判断
- 组件
- Fragment片断
- Teleport瞬移
- Suspense
- ES6
- Promise对象
- Promise作用
- 状态与过程
- 基本使用
- 常用API
- async与await
- Axios