1.Promise构造函数

Promise（excutor）{}

1. excutor函数：执行器 （resolve，reject）=>{}
2. resolve函数：内部定义成功时我们调用的函数value=>{}
3. reject函数：内部定义失败时我们调用的函数 reason=>{}

executor会在Promise内部立即同步调用，异步操作在执行器中执行

2.Promise.prototype.then方法

（onResolved,onRejected）=>{}

1. onResolved函数：成功的回调函数（value）=>{}
2. onRejected函数，失败的回调函数（reason）=>{}

指定用于得到成功value的成功回调和用于得到失败reason的失败回调，返回一个新的Promise对象

3.Promise.prototype.catch方法

(onRecjected)=>{}

1. onRejected函数：失败的回调函数（reason）=>{}

let p = new Promise((resolve,reject)=>{
	reject('error')
})

p.catch(reason=>{
	console.log(reason)
})

then()的语法糖 ，相当于then（undefined,onRejected）

4.Promise.resolve方法

（value）=>{}

1. value:成功的数据或promise对象

返回一个成功/失败的promise对象

let p1 = Promise.resolve();
console.log(p1) // Promise { <pending> }

let p1 = Promise.resolve(2);
console.log(p1) // Promise { 2 }

let p2=Promise.resolve(new Promise((resolve,reject)=>{
  reject('error')
}))
console.log(p2)//Promise { <rejected> 'error' }

let p3=Promise.resolve(new Promise((resolve,reject)=>{
  resolve('success')
}))
console.log(p3)//Promise { <fulfilled>:'success' }

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

5.Promise.reject方法

（reason）=>{}

1. reason:失败的原因

返回一个失败的promise对象

let p2=Promise.reject(new Promise((resolve,reject)=>{
  resolve('success')
}))
console.log(p2)
/*
Promise {<rejected>: Promise}
[[Prototype]]: Promise[[PromiseState]]: "rejected"
[[PromiseResult]]: Promise
*/

6.Promise.all方法

（promises）=>{}

1. promises:包含n个promise的数组

1. 返回一个新的promise，只有所有的promise都成功才成功，否则失败（执行到有一个失败会直接return 所以不存在多个失败）
2. 按顺序执行下来的

let p1= new Promise ((resolve,reject)=>{
  resolve('ok')
})
let p2 = Promise.resolve('success')
let p3 =Promise.resolve('okk')

const results = Promise.all([p1,p2,p3])
console.log(results)

let p1= new Promise ((resolve,reject)=>{
  resolve('ok')
})
let p2 = Promise.reject('error1')
let p3 =Promise.reject('error2')

const results = Promise.all([p1,p2,p3])
console.log(results)

7.Promise.race方法

（promises）=>{}

1. promises：包含n个promise的数组

1. 返回一个新的promise，第一个完成的promise的结果状态就是最终的结果状态。
2. 不是按顺序执行，是看谁先返回状态。

let p1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('ok')
  }, 1000)
})
let p2 = Promise.reject('error1')

const results = Promise.all([p1, p2])
console.log(results)