Promise.prototype.then()

MDN文档

方法返回一个 Promise . 它最多需要两个参数: Promise 的成功和失败情况的回调函数.

1
2
3
4
5
6
7
8
9
10
const promise1 = new Promise((resolve, reject) => {
  resolve('Success!');
});

promise1.then((value) => {
  console.log(value);
});

// 结果
// Success!

Promise.prototype.catch()

MDN文档

方法返回一个 Promise , 并且处理拒绝的情况. 它的行为与调用 Promise.prototype.then(undefined, onRejected) 相同

(事实上 calling obj.catch(onRejected) 内部calls obj.then(undefined, onRejected))

1
2
3
4
5
6
7
8
9
10
const p1 = new Promise((resolve, reject) => { setTimeout(reject, 100, 'foo') })

p1.then(res => {
  console.log('成功的返回: ', res)
}).catch(res => {
  console.log('失败的返回: ', res)
})

// 结果
// 失败的返回:  foo

对照

1
2
3
4
5
6
7
8
9
const p2 = new Promise((resolve, reject) => { setTimeout(resolve, 100, 'foo') })
p2.then(res => {
  console.log('成功的返回: ', res)
}).catch(res => {
  console.log('失败的返回: ', res)
})

// 结果
// 成功的返回:  foo

Promise.prototype.finally()

MDN文档

1
2
3
4
5
6
7
8
9
10
11
12
13
const p1 = new Promise((resolve, reject) => { setTimeout(reject, 100, 'foo') })

p1.then(res => {
  console.log('成功的返回: ', res)
}).catch(res => {
  console.log('失败的返回: ', res)
}).finally(() => {
  console.log('这个是p1的返回')
})

// 结果
// 失败的返回:  foo
// 这个是p1的返回

对照

1
2
3
4
5
6
7
8
9
10
11
12
const p2 = new Promise((resolve, reject) => { setTimeout(resolve, 100, 'foo') })
p2.then(res => {
  console.log('成功的返回: ', res)
}).catch(res => {
  console.log('失败的返回: ', res)
}).finally(() => {
  console.log('这是p2的返回')
})

// 结果
// 成功的返回:  foo
// 这是p2的返回

Promise.all()

MDN文档

方法返回一个 Promise 实例,此实例 iterable 参数内所有的 Promise 都完成(resolved)或参数中不包含 Promise 时回调完成(resolve); 如果参数中 Promise 有一个失败(rejected), 此示例回调失败(reject), 失败的原因是第一个失败 Promise 的结果.

他通常在启动多个异步任务并发运行并为其结果创建承诺之后使用, 以便人们可以等待所有任务完成.

接收一个 数组 作为入参

1
2
3
4
5
6
7
8
9
10
11
12
const promise1 = Promise.resolve(4)
const promise2 = 42
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo')
})

Promise.all([promise1, promise2, promise3]).then((res) => {
  console.log(res)
})

// 结果
// [4,42,"foo"]

Promise.allSettled()

MDN文档

方法返回一个在所有给定的 Promise 已被决议或被拒绝后决议的 Promise , 并带有一个对象数组, 每个对象表示对应的 Promise 结果.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
const promise1 = Promise.resolve(4)
const promise2 = 42
const promise3 = new Promise((resolve, reject) => {
  setTimeout(reject, 1000, 'foo')
})
const promise4 = new Promise((resolve, reject) => {
  setTimeout(resolve, 1000, 'foo')
})

Promise.allSettled([promise1, promise2, promise3, promise4]).then((res) => {
  console.log(res)
})

// 结果
// [
//   {
//     "status": "fulfilled",
//     "value": 4
//   },
//   {
//     "status": "fulfilled",
//     "value": 42
//   },
//   {
//     "status": "rejected",
//     "reason": "foo"
//   },
//   {
//     "status": "fulfilled",
//     "value": "foo"
//   }
// ]

Promise.any()

MDN文档

方法接收一个 Promise 可迭代对象,只要其中的一个 Promise 完成, 就返回那个已经有完成值的 Promise . 如果可迭代对象中没有一个 Promise 完成(即所有的 Promise 都失败或者拒绝) , 就返回一个拒绝的 Promise , 返回值还有待商榷: 无非是拒绝原因数组或 AggregateError 类型的实例, 他是Error的一个子类,用于把单一的错误集合在一起. 本质上这个方法和Promise.all是相反的.

这个方法是实验性的,尚未被所有的浏览器完全支持, 暂无法验证

Promise.race()

MDN文档

方法返回一个 Promise 对象, 一旦迭代器中的某个 Promise 解决或者拒绝, 返回的 Promise 就会解决或者拒绝

1
2
3
4
5
6
7
8
9
10
11
12
const promise1 = Promise.resolve(4)
const promise2 = 42
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo')
})

Promise.race([promise1, promise2, promise3]).then((res) => {
  console.log(res)
})

// 结果
// 4

Promise.resolve()

MDN文档

方法返回一个以给定值解析后的 Promise 对象. 如果这个值是一个 Promise ,那么将返回这个 promise . 如果这个值是 痛恨able (即带有 then 方法) , 返回的 promise 会跟随这个 thenable 的对象,采用他的最终状态, 否则返回的 promise 将以此值完成. 此函数将类 promise 对象的多层嵌套展平. 传入参数是一个基础值则返回这个基础值.

警告: 不要在解析为自身的 thenable 上调用 Promise.resolve. 这将导致无限递归, 因为他试图展平无限嵌套的 promise .

1
2
3
4
5
6
7
8
const promise1 = Promise.resolve(123);

promise1.then((value) => {
  console.log(value);
});

// 结果
// 123

Promise.reject()

MDN文档

返回一个带有拒绝原因的 Promise 对象

1
2
3
4
5
6
7
8
9
10
11
12
function resolved(result) {
  console.log('Resolved');
}

function rejected(result) {
  console.error(result);
}

Promise.reject(new Error('fail')).then(resolved, rejected);

// 结果
// Error: fail