Promise
1. 原型方法（对象方法）：需要创建出一个对象才能调用
  1. let promise = new Promise(); promise.then()
2. 静态方法（类方法）：直接调用Promise.all()
3. then方法：then方法可以链式调用的原因是因为then方法本身返回了一个新的promise
  1. 当then方法返回了一个普通值/普通对象或者没有返回值时（默认返回undefined），那么这个值将被作为新的Promise的resolve的值。假如返回了Bear，那么就是返回了
    1. return new Promise('Bear')
  2. 当then方法返回了一个Promise对象时，返回的这个Promise对象也会被当作是新创建的Promise对象的resolve值。比如返回了x，x是一个promise对象，那么then方法就会返回
    1. return new Promise(resolve => resolve(x))
  3. 当then方法返回了一个对象，并且该对象实现了thenable。比如，返回了一个obj，obj里有一个then方法，那么then方法就会返回
    1. return new Promise(resolve => resolve(obj.then)) ```javascript // Promise有哪些对象方法 // console.log(Object.getOwnPropertyDescriptors(Promise.prototype))

const promise = new Promise((resolve, reject) => { resolve(“hahaha”) })

// 1.同一个Promise可以被多次调用then方法 // 当我们的resolve方法被回调时, 所有的then方法传入的回调函数都会被调用 // promise.then(res => { // console.log(“res1:”, res) // })

// promise.then(res => { // console.log(“res2:”, res) // })

// promise.then(res => { // console.log(“res3:”, res) // })

// 2.then方法传入的 “回调函数: 可以有返回值 // then方法本身也是有返回值的, 它的返回值是Promise

// 1> 如果我们返回的是一个普通值(数值/字符串/普通对象/undefined), 那么这个普通的值被作为一个新的Promise的resolve值 // promise.then(res => { // return “aaaaaa” // }).then(res => { // console.log(“res:”, res) // return “bbbbbb” // })

// 2> 如果我们返回的是一个Promise // promise.then(res => { // return new Promise((resolve, reject) => { // setTimeout(() => { // resolve(111111) // }, 3000) // }) // }).then(res => { // console.log(“res:”, res) // })

// 3> 如果返回的是一个对象, 并且该对象实现了thenable promise.then(res => { return { then: function(resolve, reject) { resolve(222222) } } }).then(res => { console.log(“res:”, res) })

catch
1. ES6 中为了提高代码可读性，引入了catch方法 便与我们去捕捉异常
1. catch方法的返回值跟then是一样的
```javascript
let promise = new Promise((resolve, reject) => {
  reject('111');
})
promise.then((res) => {
  resolve('222')
}).then((res) => {
  reject('333')
}).catch((reason) => {
  console.log('reason ', reason)
})
// catch会优先捕获外层的reject，即会捕获promise的reject，输出111

// const promise = new Promise((resolve, reject) => {
//   resolve()
//   // reject("rejected status")
//   // throw new Error("rejected status")
// })
// 1.当executor抛出异常时, 也是会调用错误(拒绝)捕获的回调函数的
// promise.then(undefined, err => {
//   console.log("err:", err)
//   console.log("----------")
// })
// 2.通过catch方法来传入错误(拒绝)捕获的回调函数
// promise/a+规范
// promise.catch(err => {
//   console.log("err:", err)
// })
// promise.then(res => {
//   // return new Promise((resolve, reject) => {
//   //   reject("then rejected status")
//   // })
//   throw new Error("error message")
// }).catch(err => {
//   console.log("err:", err)
// })
// 3.拒绝捕获的问题(前面课程)
// promise.then(res => {
// }, err => {
//   console.log("err:", err)
// })
// const promise = new Promise((resolve, reject) => {
//   reject("111111")
//   // resolve()
// })
// promise.then(res => {
// }).then(res => {
//   throw new Error("then error message")
// }).catch(err => {
//   console.log("err:", err)
// })
// promise.catch(err => {
// })
// 4.catch方法的返回值
const promise = new Promise((resolve, reject) => {
  reject("111111")
})
promise.then(res => {
  console.log("res:", res)
}).catch(err => {
  console.log("err:", err)
  return "catch return value"
}).then(res => {
  console.log("res result:", res)
}).catch(err => {
  console.log("err result:", err)
})

then和catch方法都是可以被多次调用的，且都是独立的

finally

无论promise的状态变成fulfilled还是rejected，最终都是会被执行的
finally方法是不接受参数的 ```javascript const promise = new Promise((resolve, reject) => { // resolve(“resolve message”) reject(“reject message”) })

promise.then(res => { console.log(“res:”, res) }).catch(err => { console.log(“err:”, err) }).finally(() => { console.log(“finally code execute”) })

```

代码随想录题目汇总

数组：
1. 二分查找：704、35、34、69、367
2. 移除元素：27、26、283、844、977
3. 有序数组的平方：977
4. 长度最小的子数组：209、904、76
5. 螺旋矩阵：59、54、剑指offer 29
链表：
1. 移除链表元素：203
2. 设计链表：707
3. 反转链表：206
4. 两两交换链表中的节点：24
5. 删除链表的倒数第N个节点：19
6. 链表相交：面试题02.07
7. 环形链表2：142
哈希表：
1. 有效的字母异位词：242、383、49、438
2. 两个数组的交集：349、350
3. 快乐数：202
4. N数之和：1、15、18
5. 四数相加2：454
6. 赎金信：383
字符串
1. 反转字符串：344、541
2. 替换空格：剑指offer05
3. 翻转字符串里的单词：151
4. 左旋转字符串：剑指offer 58 2
5. 实现strStr()：28
6. 重复的子字符串：459
双指针法
1. 移除元素：27、26、283、844、977
2. 反转字符串：344、541
3. 替换空格：剑指offer05
4. 翻转字符串里的单词：151
5. 反转链表：206
6. 删除链表的倒数第N个节点：19
7. 链表相交：面试题02.07
8. N数之和：1、15、18
9. 环形链表2：142
栈与队列
1. 用栈实现队列：232
2. 用队列实现栈：225
3. 有效的括号：20
4. 删除字符串中所有相邻重复项：1047
5. 逆波兰表达式求值：150
6. 滑动窗口最大值：239
7. 前K个高频元素：347
二叉树
1. 二叉树的遍历方式：144、145、94、102
2. 二叉树的属性：101、104、111、222、110、157、404、513、112
3. 二叉树的修改与构造：226、106、654、617
4. 求二叉搜索树的属性：700、98、530、501、538
5. 二叉树公共祖先问题：236、235
6. 二叉搜索树的修改与构造：701、450、669、108
回溯算法
1. 组合：77、17、39、40、216
2. 分割：131、93
3. 子集：78、90
4. 排列：46、47
5. 棋盘：51、37
6. 其他：491、332
贪心算法
1. 简单：455、1005、860
2. 中等
  1. 序列问题：376、738
  2. 股票问题：122、714
  3. 两个维度权衡问题：135、406
3. 有点难度
  1. 区间问题：55、45、452、435、763、56
  2. 最大子序和：53
  3. 加油站：134
  4. 监控二叉树：968
动态规划
1. 基础：509、78、746、62、63、343、96
2. 背包问题
  1. 01背包：416、1049、494、474
  2. 完全背包：518、377、70、322、279、139
  3. 多重背包：无
3. 打家劫舍：198、213、337
4. 股票问题：121、122、123、188、309、714
5. 子序列问题
  1. 子序列（不连续）：300、1143、1035
  2. 子序列（连续）：674、718、53
  3. 编辑距离：392、115、583、72
  4. 回文：647、516
单调栈：739、496、503、42、84
额外：
1. 数组：1365、941、1207、283、189、724、34、922、35
2. 链表：24、234、143、141
3. 哈希表：205
4. 字符串：925、844
5. 二叉树：129、1382、100、116
6. 回溯：52
7. 贪心：649、1221
8. 动态规划：5、132、673
9. 图论：841、127
10. 并查集：684、685
11. 模拟：657、31、463
12. 位运算：1356

算法

Day Summary

2022.06.09

then和catch方法都是可以被多次调用的，且都是独立的

代码随想录题目汇总