斗胆谈谈Promise
作者：互联网
1.Promise概念
1.1为什么需要promise？
promise是ES6异步编程新的解决方案，它可以用来解决回调地狱的问题，回调地狱就是许多回调函数嵌套，导致代码太乱了，不易读，也不太好看。如下代码（读文件是异步操作，需要回调函数不停嵌套，透露出一股恶心劲）
fs.readFile('./1.html',(err,data)=>{
if(err) throw err;
fs.readFile('./2.html',(err,data1)=>{
if(err) throw err;
fs.readFile('./3.html',(err,data2)=>{
if(err) throw err;
fs.readFile('./4.html',)
})
})
})1.2promise是什么？
promise其实就是一个构造函数，它里面包含一些属性和方法，支持链式调用。
promise其中一个属性PromiseState代表它的状态，它只有三种状态：
fulfilled/resolved（成功）
rejected （失败）
pending （进行中，最初的状态）
其中只会有两种情况的状态变化:
pending -> fulfilled/resolved
pending->rejected
就是只能从初始变为成功，或者从初始变为失败，成功和失败之间不能再互相转化了。
下面我们通过具体的使用来了解。
2.Promise使用
2.1创建promise
上代码（最简单的promise使用，定义一个成功的promise）
let p = new Promise((resolve,reject)=>{
resolve('ok')
})
console.log(p);输出P是一个promise实例，它的状态是成功的，PromiseResult是promise的另一个属性，代表promise的值。
定义一个失败的promise
let p = new Promise((resolve,reject)=>{
reject('fail')
})
console.log(p); 输出结果是P是一个promise但他的状态是rejected失败的，promise的值就是传入的值
2.2promise的方法
then（）：
then方法的参数可以传入两个回调函数，当promise状态变为成功（ fulfilled）时，执行第一个参数接受的回调函数，状态变为失败（rejected）执行第二个参数接收的回调函数，注意then方法返回的仍然是一个promise对象，所以在then方法之后可以继续调用then方法
上代码
let p = new Promise((resolve,reject)=>{
reject('fail')
})
p.then((value)=>{
console.log('成功',value);
},(reason)=>{
console.log('失败',reason);
})
当一个rejected状态的promise调用.then时执行的是第二个参数的回调函数，所以输出失败，值就是通过reject()传入的值
let p = new Promise((resolve,reject)=>{
resolve('ok')
})
p.then((value)=>{
console.log('成功',value);
},(reason)=>{
console.log('失败',reason);
})
同理，当一个resolve状态的promise调用.then时，执行的是第一个参数的回调函数，输出成功，value值就是通过resolve()传入的值
那我们说then返回的也是一个promise对象，若then里面的回调函数返回的是非promise的数值那么then返回的就是resolved/fulfilled状态的promise，
如果then里面的回调函数返回的是promise类型，则回调函数返回的promise的成功与否直接决定了then方法返回的promise的结果和状态（有些绕，看代码就清楚了）
上代码（回调函数返回非promise）
let p = new Promise((resolve,reject)=>{
resolve('ok')
})
const res = p.then((value)=>{
console.log('成功',value);
},(reason)=>{
console.log('失败',reason);})
console.log(res);
p是resolved状态的，那么执行then里面的第一个回调函数，打印成功，回调函数并没有返回一个新的promise，因此p.then返回的就是一个状态为fulfilled的promise,值为undifined，因为没有新的promise对象。
回调函数返回promise
let p = new Promise((resolve,reject)=>{
resolve('ok')
})
const res = p.then((value)=>{
return new Promise((resolve,reject)=>{
resolve('new Promise')
})
},(reason)=>{
console.log('失败',reason);})
console.log(res);
因为成功的回调函数返回了一个新的promise，他决定了then返回的promise的状态和值也是成功的，值就是传入的新值
let p = new Promise((resolve,reject)=>{
resolve('ok')
})
const res = p.then((value)=>{
return new Promise((resolve,reject)=>{
reject('fail Promise')
})
},(reason)=>{
console.log('失败',reason);})
console.log(res);
若回调函数返回的是失败的promise，则then返回的也是失败的promise，值就是传入的值
catch（）
promise还有一个特点是可以进行异常穿透，就是已经失败了，就不要总是定义失败（reject）的回调函数了，只要在最后指定一个失败的回调catch()就好了，捕获失败结果，返回值就第一个失败的值，这样代码就更清晰了。
let p1 = new Promise((resolve,reject)=>{
reject('fail')
})
p1.then((value)=>{
console.log('成功',value);
}).catch(e=>
{
console.log('失败',e);
})失败的promis执行catch（），then方法里面不用再写失败的回调了
如果.then后面还有.then，许许多多.then也不怕，catch仍然能抓到第一个失败的值
let p1 = new Promise((resolve,reject)=>{
resolve('ok')
})
p1.then(value=>{
console.log('111');
}).then(value=>{
console.log('222');
throw('ERROR')
}).then(value=>{
console.log('333');
}).catch(reason=>{
console.log('失败',reason)
})
成功的promise会继续执行.then方法，直到catch捕获到了第一个失败，就不再继续执行了，不会输出33333
all（）
promise.all传入的是一个promise类型的数组，它的返回值也是一个promise，他的状态由数组决定，若promise数组里均为resolved状态的，那么promise.all返回的就是resolved状态的，值就是由所有传入值组成的数组，若promise数组中有一个失败了，那么promise.all返回的就是reject状态的，值就是失败的传入的值
上代码（promise全为成功状态）
let p1 = new Promise((resolve,reject)=>{
resolve('ok')
})
let p2 = new Promise((resolve,reject)=>{
resolve('success')
})
let p3 = new Promise((resolve,reject)=>{
resolve('nice')
})
const res = Promise.all([p1,p2,p3])
console.log(res);
有一个为失败状态
let p1 = new Promise((resolve,reject)=>{
resolve('ok')
})
let p2 = new Promise((resolve,reject)=>{
reject('fail')
})
let p3 = new Promise((resolve,reject)=>{
resolve('nice')
})
const res = Promise.all([p1,p2,p3])
console.log(res);
race（）
promise.all传入的也是一个primise数组，返回值是一个promise，只是它的状态和值是由最先发生变化的promise状态和值决定的，就像赛跑先到先得
let p1 = new Promise((resolve,reject)=>{
resolve('ok')
})
let p2 = new Promise((resolve,reject)=>{
reject('fail')
})
let p3 = new Promise((resolve,reject)=>{
resolve('nice')
})
const res = Promise.race([p1,p2,p3])
console.log(res);
P1先到，是成功的，值是ok，则all方法返回的promise是成功的值为ok
若P1变为异步了，则p2先到那么结果一定会是一个返回失败的promise
let p1 = new Promise((resolve,reject)=>{
setTimeout(()=>{
resolve('ok')
})
})
let p2 = new Promise((resolve,reject)=>{
reject('fail')
})
let p3 = new Promise((resolve,reject)=>{
resolve('nice')
})
const res = Promise.race([p1,p2,p3])
console.log(res);
4.async await
async是一个函数，返回结果是一个promise对象
1.如果函数里面return的不是一个promise，那promise的结果就是成功的，值就是return的数值
2.如果函数里面return的是一个promise，那async的Promise就是return的promise
3.抛出异常，返回的就是失败的promise对象
（这个很像对于then方法那个表述）
await右边表达式一般为promise对象
1.右边是promise对象，await返回值是promise成功值
2.右边是其他值，直接将此值作为await的返回值（很少用）
注意二者常常结合使用简化promise操作
await必须写在async里面，但是async可以没有await
上代码
async function main(){
let p = new Promise((resolve,reject)=>{
resolve('ok')
// reject('error')
})
try{
let res = await p;
console.log(res);
}catch(e){
console.log(e);
}
}
main()
await返回的是promise的成功值，所以需要用try catch捕获失败的情况，输出ok，以后就可以用这样的方法简化promise操作，只需要awaitpromise成功的值即可
标签：斗胆,resolve,console,new,谈谈,Promise,reject,promise 来源： https://blog.csdn.net/weixin_43946748/article/details/121568393