前世今生
    javascript语言中所有执行程序都是单线程，javascript为了解决程序阻塞（I/O操作、事件操作），也支持了异步操作。但是异步操作在javascript处理都是通过回调callback方法，来处理的。为了解决javascript回调地狱问题，promise出现了。

    promise概述

    • promise有三个状态：
      1、pending[待定]初始状态
      2、fulfilled[实现]操作成功
      3、rejected[被否决]操作失败
      promise状态一经改变，不会再变。
    • Promise对象的状态改变，只有两种可能：
      从pending变为fulfilled
      从pending变为rejected。

    promise API

    • Promise.prototype.then
    • Promise.prototype.catch
    • Promise.prototype.finally
    • Promise.resolve
    • Promise.reject
    • Promise.all
    • Promise.race

    promise使用案例

    1. (async () => f())().then(res => console.log).cathc(res => console.log)
    4. (
    5.   () => new Promise(
    6.     resolve => resolve(f())
    7.   )
    8. )().then(res => console.log).cathc(res => console.log)

    promise使用

    1. var ajax = () => {
    2.  return new Promise((resolve,reject) => {
    3.   $.ajax({
    4.     url,
    5.     type:'get',
    6.     success:() => {
    7.      resolve(res)
    8.     },
    9.     error:(res) => {
    10.       reject(res)
    11.     }
    12.   })
    13.  })
    14. }
    16. ajax().then(res => {
    17.   console.log(res)
    18. }).cathch(res => {
    19.   console.log(res)
    20. })

    Promise.prototype.then
    then方法执行来自promise中resolve返回的结果例：

    1. var fn = () => {
    2.   return new Promise((resolve,reject) => {
    3.      setTimeout(() => {
    4.          resolve('hello word')
    5.      })
    6.   })
    7. }
    8. //这里then方法执行来自promise中resolve返回的结果
    9. fn().then(res => console.log(res))
    10. //hello word
    12. //注：then方法可以接受两个function 如果有第二个function相当语catch 接受来自reject的结果
    13. fn().then(res=>{},err=>{console.log(err,'err')})

    Promise.prototype.catch
    catch执行来自promise中reject返回的结果

    1. var fn = () => {
    2.   return new Promise((resolve,reject) => {
    4.      setTimeout(() => {
    5.        reject('hello word')
    6.      })
    8.   })
    9. }
    10. //catch执行来自promise中reject返回的结果
    11. fn().then(res => console.log(res)).catch(res => console.log('error',res))
    13. //error hello word

    promise.prototype.finally
    finally不管结果是在then还是catch都会执行

    1. fn()
    2. .then(res => console.log(res))
    3. .catch(res => console.log('error',res))
    4. .finally(res => console.log('finally',res))
    6. //finally不管结果是在then还是catch都会执行
    7. error hello word
    8. finally undefined

    promise.resolve

    promise.resolve可以理解成是new Promise((resolve,reject) => {}) resolve 的简写方式

    1. Promise.resolve('hello word')
    2. .then(res => {console.log(res)})
    3. //hello word

    promise.reject
    promise.resolve可以理解成是new Promise((resolve,reject) => {}) reject 的简写方式

    1. Promise.reject('hello word')
    2. .then(res => {console.log(res,'error')})
    3. //hello word error

    promsie.all
    promsie.all接受一个数组array 数组元素都是一个或多个promsie、所有的元素promsie必须都执行then、
    最后才会执行promise.all().then 否则执行promise.all().catch()

    1. var f1 =  async() => 'hello'
    3. var f2 = async() => 'word'
    5. var f3 = async() => Promise.reject('xixi')
    7. Promise.all([f1(),f2(),f3()])
    8. .then(res => console.log(res))
    9. .catch(res => console.log(res,'error')) 
    11. //promsie.all接受一个数组array  数组元素都是一个或多个promsie、
    12. //所有的元素promsie必须都执行then、
    13. //最后才会执行promise.all().then  否则执行promise.all().catch()
    15. //这里执行结果是
    16.  xixi error

    Promise.race
    promsie.race方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。

    1. const p = Promise.race([p1, p2, p3]);

    上面代码中，只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。
    Promise.race方法的参数与Promise.all方法一样，如果不是 Promise 实例，就会先调用下面讲到的Promise.resolve方法，将参数转为 Promise 实例，再进一步处理。
    下面是一个例子，如果指定时间内没有获得结果，就将 Promise 的状态变为reject，否则变为resolve。

    1. const p = Promise.race([
    2.   fetch('/resource-that-may-take-a-while'),
    3.   new Promise(function (resolve, reject) {
    4.     setTimeout(() => reject(new Error('request timeout')), 5000)
    5.   })
    6. ]);
    7. p
    8. .then(console.log)
    9. .catch(console.error);

    上面代码中，如果 5 秒之内fetch方法无法返回结果，变量p的状态就会变为rejected，从而触发catch方法指定的回调函数。

    promise总结
    **
    1.promise中then或者catch都是可以return 一个结果的，可以是任意值，也可以是重新定义promise。

    2.promise中使用return一个的值，它相当于Promise.resolve(‘任意值’)。

    3.then方法其实也是可以接受两个参数的，第二个参数也是function，作用用catch一样。

    4.race方法时由第一个转变状态的小Promise的状态决定，第一个是成功态，则转成功态，第一个失败态，则转失败态。

    5.reject方法可以生成一个失败的Promise 、Promise.reject(‘出错了’)等同于new Promise((resolve, reject) => reject(‘出错了’))

    来自promise文章

    promise值得借鉴的写法

    1.Promise.resolve({then:fn2})的用法

    1. //定义异步方法
    2. var fn2 = (resolve,reject) => {
    3.   setTimeout(() => {
    4.     reject('fn2')
    5.   },800)
    6. }
    8. //使用异步方法
    9. (async () => Promise.resolve({then:fn2}))()
    10. .then(console.log)
    11. .catch(console.log)
    13. //也可以使用
    14. (async () => new Promise(fn2))()
    15. .then(console.log)
    16. .catch(console.log);
    17. console.log('haha');

    2.定义一个自执行的promise

    1. //定义一个自执行的promise
    2. const f = () => console.log('now');
    3. (
    4.   () => new Promise(
    5.     resolve => resolve(f())
    6.   )
    7. )();
    8. console.log('next');
    9. // now
    10. // next

    3.async 、Promise结合用法

    1. var f1 = (resolve,reject) => {
    2.   resolve('haha')
    3. } 
    5. var f2 = (resolve,reject) => {
    6.   setTimeout(() => {resolve('f2')},1000)
    7. }
    9. var f3 = (resolve,reject) => {
    10.   setTimeout(() => {resolve('f3')},200)
    11. }
    13. (async () => {
    14.   let res1 = await new Promise(f1);
    15.   let res2 = await new Promise(f2);
    16.   let res3 = await new Promise(f3);
    17.   console.log(res1);
    18.   console.log(res2);
    19.   console.log(res3);
    20.   return 'ok l'
    21. })().then(console.log)
    22. .catch(console.log)