学习笔记四promise

---

1.Promise 的状态

实例对象promise中的一个属性 PromiseState
pending 未决定的

pending 变为 resolved/fullfilled
pending 变为 rejected

注意

对象的状态不受外界影响
只有这两种，且一个 promise 对象只能改变一次
一旦状态改变，就不会再变，任何时候都可以得到这个结果
无论成功还是失败，都会有一个结果数据。成功的结果数据一般称为 value，而失败的一般称为 reason。

2. Promise对象的值

实例对象promise的另一个值 PromiseResult
保存着对象 成功/失败 的值（value/reason）

resolve/reject可以修改值

promise中的函数同步执行，.then() 中的回调函数异步执行

catch来代替.then中的第二个函数

.then(
 value => { // onResolved()函数
  console.log(value) // 成功的数据
}
).catch(
 reason => { // onRejected()函数
  console.log(reason) // 失败的数据
}
)

注意 以下方法的返回值都是promise对象 可以.then

3. promise的方法

Promise.resolve 方法：Promise.resolve(value)

如果传入的参数为 非Promise类型的对象, 则返回的结果为成功promise对象 值为传入的值
如果传入的参数为 Promise 对象, 则参数的结果决定了 resolve 的结果 值为传入的promise对象的值

Promise.reject 方法：Promise.reject(reason)

返回一个失败的 promise 对象
传进去什么 值就是什么

---

Promise.resolve()/Promise.reject() 方法就是一个语法糖
用来快速得到Promise对象

//产生一个成功值为1的promise对象
new Promise((resolve, reject) => {
 resolve(1)
})
//相当于
const p1 = Promise.resolve(1)
const p2 = Promise.resolve(2)
const p3 = Promise.reject(3)

p1.then(value => {console.log(value)}) // 1
p2.then(value => {console.log(value)}) // 2
p3.catch(reason => {console.log(reason)}) // 3

Promise.all 方法：Promise.all(iterable)

包含 n 个 promise 对象的数组(返回值也是promise对象)

说明：返回一个新的 promise对象，只有所有的 promise 都成功才成功，只要有一个失败了就直接失败
若成功 结果是一个装着每个成功的结果的数组
若失败 结果是那个失败的promise的值

const p1 = Promise.resolve(1)
const p2 = Promise.resolve(2)
const p3 = Promise.reject(3)

const pAll = Promise.all([p1, p2, p3])
const pAll2 = Promise.all([p1, p2])
//因为其中p3是失败所以pAll失败
pAll.then(
value => {
   console.log('all onResolved()', value)
 },
reason => {
   console.log('all onRejected()', reason) 
 }
)
// all onRejected() 3
pAll2.then(
values => {
   console.log('all onResolved()', values)
 },
reason => {
   console.log('all onRejected()', reason) 
 }
)
// all onResolved() [1, 2]

Promise.race方法：Promise.race(iterable)

iterable：包含 n 个 promise 的可迭代对象，如 Array 或 String

说明：返回一个新的 promise，第一个完成的 promise 的结果状态就是最终的结果状态
谁先完成就输出谁(不管是成功还是失败)
相当于多个promise对象在赛跑 race
————————————————

Promise 的几个关键问题

1. 如何改变 promise 的状态？

(1)resolve(value)：如果当前是 pending 就会变为 resolved

(2)reject(reason)：如果当前是 pending 就会变为 rejected

(3)抛出异常throw：如果当前是 pending 就会变为 rejected
此时promise的结果都是传入的结果

2. 一个 promise 指定多个成功/失败回调函数，都会调用吗？

当 promise 改变为对应状态时都会调用

3. 改变 promise 状态和指定回调函数谁先谁后？

注意 指定回调是指执行then 而不是执行then里面的函数
都有可能，常规是先指定回调再改变状态，但也可以先改状态再指定回调

let p = new Promise((resolve, reject) => {
 setTimeout(() => {
      resolve('OK');
   }, 1000); // 有异步就先指定回调，否则先改变状态
});

p.then(value => {
  console.log(value);
},reason=>{
  
})

这时先指定回调 再改变状态

什么时候才能得到数据？

(1)如果先指定的回调，那当状态发生改变时，回调函数就会调用得到数据

(2)如果先改变的状态，那当指定回调时，回调函数就会调用得到数据

注意!!!

promise函数里面的函数是同步执行 但是函数里面的回调函数是异步的
比如说 setimeout可以立刻执行 但是计时器一定会有回调函数 这个回调函数是异步的
then函数里面会有回调函数 它是异步的

promise.then() 返回的新 promise 的结果状态由什么决定？

(1)简单表达：由 then() 指定的回调函数执行的结果决定
返回的Promise结果为 它的值

①如果抛出异常，新 promise 变为 rejected，reason 为抛出的异常
② 如果return的是非 promise 的任意值，新 promise 变为 resolved，value 为返回的值 (若没有return return就是undefined)
③ 如果返回的是另一个新 promise，此 promise 的结果就会成为新 promise 的结果

5.promise 如何串联多个操作任务？

(1)promise 的 then() 返回一个新的 promise，可以并成 then() 的链式调用

let p = new Promise((resolve, reject) => {
  setTimeout(() => {
      resolve('OK');
  }, 1000);
});

p.then(value => {
  return new Promise((resolve, reject) => {
      resolve("success");
}).then(value => {
  console.log(value); // success
}).then(value => {
  console.log(value); // undefined
})

(2)通过 then 的链式调用串联多个同步/异步任务

new Promise((resolve, reject) => {
  setTimeout(() => {
    console.log('执行任务1(异步)')
    resolve(1)
  }, 1000)
}).then(
  value => {
    console.log('任务1的结果', value)
    console.log('执行任务2(同步)')
    return 2 // 同步任务直接return返回结果
  }
).then(
  value => {
    console.log('任务2的结果', value)
    return new Promise((resolve, reject) => { // 异步任务需要包裹在Promise对象中
      setTimeout(() => {
        console.log('执行任务3(异步)')
        resolve(3)
      }, 1000)
    })
  }
).then(
  value => {
    console.log('任务3的结果', value)
  }
)
// 执行任务1(异步)
// 任务1的结果 1
// 执行任务2(同步)
// 任务2的结果 2
// 执行任务3(异步)
// 任务3的结果 3

6.Promise 异常穿透(传透)？

(1)当使用 promise 的 then 链式调用时，可以在最后指定失败的回调

(2)前面任何操作出了异常，都会传到最后失败的回调中处理

.then()
.then()
.catch()

7.中断 promise 链？

当使用 promise 的 then 链式调用时，在中间中断，不再调用后面的回调函数

办法：在回调函数中返回一个 pending 状态的 promise 对象
相当于状态没有改变 只要前面的状态不改变 后面的就都不会执行

return new Promise(() => {}) // 返回一个pending的promise