说说promise吧, promise 许诺。Promise的明白就是 我对你做出许诺,我怎样怎样,然后我有能够胜利,我做到了, 有能够失利, 我没做到, 就是这么个东西.(说的玄一点, 这是一个异步流程掌握的一个东东, 至于什么是异步流程掌握？我不知道)

new Promise((resolve, reject)=>{})

Promise的状况变化有两种, 从pending —> fulfilled或许 pending—>rejected

pending 是初始的状况, fulfilled 是胜利的状况, 剩下的就是失利的状况rejected

Promise会马上实行, 然则状况的转变须要我们来操纵。

let abcc = new Promise((resolve, reject)=> {
  console.log('马上实行了')
  setTimeout(()=>{
   resolve('ccc')
  },1000)
  setInterval(()=> {
    console.log(abcc)
  },200)
  console.log('马上实行了2')
})

then

当Promise的状况发作转变，运用then要领来触发对应的处置惩罚要领.

两个参数: then要领包括两个参数, 对应该Promise的状况为fulfilled和rejected的回调函数

省略参数: 将建立一个没有其他处置惩罚顺序的新的Promise，继续Promise终究的状况, then被挪用， 第几个参数省略,Promise将采纳谁人状况

由于then要领返回的是一个新的Promise对象, 所以不会影响到当前的Promise对象，由于返返来的是Promise，所以then背面能够then, then， then….无穷无尽，如许圆满的避免了 回调地狱.

let o1 = new Promise((resolve,reject) => {
   resolve(1)
})

o1.then((value)=>{
    console.log('value'+ value)   // 1
    console.log(o1)    // resolved 1
   value +=1;
   return value;
}).then((value)=>{
   console.log(value)      //2
console.log(o1)   //resolved 1 
})

catch

由于我们写的是顺序, 所以常常要斟酌顺序失足的原因. 就把rejected的函数捕获给暴露出来了就是所谓的catch, 当状况变成rejected的时刻, catch被挪用

实在catch就是下面的缩写

Promise.prototype.then(undefined, onRejected)

看下下面这个

var p1 = new Promise(function(resolve, reject) {
  resolve('Success');
});

p1.then(function(value) {
  console.log(value); // "胜利!"
  throw 'oh, no!'; or   return Promise.reject('oh no ')
}).catch(function(e) {
  console.log(e); // "oh, no!"  
}).then(function(){
  console.log('after a catch the chain is restored');
}, function () {
  console.log('Not fired due to the catch');
});

catch返回的Promise状况， 由于catch是then(undefined, onrejected)的缩写, 第一个参数为空, 所以catch返回的Promise状况为胜利

Promise.reject(reson)

返回一个用reason谢绝的Promsie

let o = Promise.reject('sss');
o.catch((reason) => {
  console.log(reason)     // sss
}).then(()=> {
 console.log('resolve')    // 返回这个 来由在上面本身找
}, ()=> {
  console.log('reject')
})

Promise.resolve()

Promise.resolve(value); 一般剖析
Promise.resolve(promise);  依据promise的状况交游下通报
Promise.resolve(thenable);  依据then的状况交游下通报

Promise.resolve("Success").then(function(value) {
  console.log(value); // "Success"
}, function(value) {
  // 不会被挪用
})

Promise.all()

当一切参数中的promise都完成, 或许恣意一个promise的状况变成reject，返回promise

let o1 = new Promise((resolve,reject)=>{
   resolve('1')
})

let o2 = new Promise((resolve,reject)=>{
   resolve('2')
})

let o3 = new Promise((resolve,reject)=>{
   setTimeout(()=> {
     resolve('3')
   }, 3000)
})

Promise.all([o1, o2, o3]).then((value)=>{
  console.log(value)
}).catch((reason)=>{
  console.log(reason)
})

Promise.race()

和all相反, 只需有一个状况转变, 就会返回

能够讲上面的all换成race来玩玩.