ES6 Promise

摘要：可以捕获返回值返回一个，处理状态变为的情况参数是一个函数，有一个参数，用来记录变成状态返回的原因。示例用于将现有对象转为对象等价于返回值返回一个对象，这个对象是被给定的值解析过的。

参考
https://pouchdb.com/2015/05/1...
https://developer.mozilla.org...
http://es6.ruanyifeng.com/#do...

是一种编写异步代码的方法。

用于表示一个异步操作的最终状态（完成或失败），以及该异步操作的结果值。

Promise适用于这样的场景，后面的操作必须根据前面的操作的结果做出相应的反应。 那么后面的操作必须等前面的操作完成并且获得前面操作的结果。

假设我们现在有三个操作doSomethingFirst，doSomethingSecond 和finalHandler。
doSomethingSecond 需要根据 doSomethingFirst 的结果做出反应
finalHandler 需要根据 doSomethingSecond 的结果做出反应
流程如下：

//resOfDoSomethingFirst 是 DoSomethingFirst的结果
  doSomethingFirst
|-----------------|
                  doSomethingSecond(resOfDoSomethingFirst)
                  |------------------|
                                     finalHandler(doSomethingSecond的结果)
                                     |------------------|
实现这个场景需要解决以下两个问题：
    后面的操作 如何知道 前面的操作 完成了
    后面的操作 如何知道 前面的操作 的执行结果是什么

//包装第一个操作在 doSomethingFirst 中
const doSomethingFirst = new Promise(function(resolve, reject) {
  // ... some code

  if (/*操作成功 */){
    resolve(doSomethingFirstValue);     //将doSomethingFirst对象的状态从“pending”变为“resolved”
  } else {
    reject(doSomethingFirstError);
  }
});

//包装第二个操作在 
doSdoSomethingSecond(resOfDoSomethingFirst) {
      // ... some code
    return somePromise(); //返回一个promise 对象
});

//整个操作流程如下：
doSomethingFirst()
    .then(doSdoSomethingSecond)
    .then(finalHandler)
    .catch(function (err) {
      console.log(err);
    })
    .finally(() => {···});
    
通过new Promise创建的Promise 实例doSomethingFirst 有以下方法：
    Promise.all(iterable)
    Promise.race(iterable)
    Promise.reject(reason)
    Promise.resolve(value)
    Promise.prototype.catch(onRejected)
    Promise.prototype.then(onFulfilled, onRejected)
    Promise.prototype.finally(onFinally)

1. doSomethingSecond 如何知道 doSomethingFirst 操作完成了
    通过doSomethingFirst状态的变更通知。

    一个 Promise有以下几种状态:
        pending: 操作未完成。
        fulfilled: 操作完成，并且成功。
        rejected: 操作完成，但是失败。

    resolve()函数：
        在异步操作成功时调用
        作用是：将Promise对象的状态从 pending 变为 fulfilled，并将异步操作的结果，作为参数传递出去；
    reject()函数：
        在异步操作失败时调用
        作用是：将Promise对象的状态从 pending 变为 rejected， 并将异步操作的错误，作为参数传递出去。

    当操作完成时(Promise对象的状态变为fulfilled 或 rejected时)，doSomethingFirst 就会通过then()函数调用doSomethingSecond，doSomethingSecond就知道doSomethingFirst已经完成了。
2. doSomethingSecond 如何知道 doSomethingFirst 的执行结果是什么
    doSomethingFirst通过给then()函数调用doSomethingSecond(resOfDoSomethingFirst)并把执行结果resOfDoSomethingFirst作为参数传递给doSomethingSecond

用于为 Promise 实例添加状态改变时的回调函数
返回值：一个新的 Promise，所可以采用链式写法，then()函数后面再调用then()函数
参数：
    onFulfilled 
        是一个函数，有一个参数，用来记录变成fulfilled状态返回的结果
        当doSomethingFirst这个Promise的状态变成fulfilled 时，onFulfilled作为回调函数被调用
    onRejected
        是一个函数，有一个参数，用来记录变成rejected状态返回的原因
        当doSomethingFirst这个Promise的状态变成rejected 时，onRejected作为回调函数被调用

    在当前的例子里参数onFulfilled就是doSomethingSecond(resOfDoSomethingFirst)，resOfDoSomethingFirst 记录了doSomethingFirst 变成fulfilled状态返回的结果。

注意事项：
    当给then()传入的参数不是函数时，它实际上将其解释为then（null），将使先前的Promise的结果落空
        Promise.resolve("foo").then(Promise.resolve("bar")).then(function (result) {
          console.log(result); // foo
        });    
            等价于
        Promise.resolve("foo").then(null).then(function (result) {
            console.log(result);// foo 
        });
    
        上面的代码并没有按照我们期望的打印"bar", 而是打印"foo"
        正确的写法是：
        Promise.resolve("foo").then(function () {
          return Promise.resolve("bar");
        }).then(function (result) {
          console.log(result); // bar
        });


给then()传入的参数是函数时，函数的内部我们可以做以下三件事：
    1. 返回另外一个promise
    2. 返回一个同步值
    3. 抛出一个同步错误

    示例：返回另外一个promise
        doSomethingFirst()
            .then(doSdoSomethingSecond)
            .then(finalHandler)
    
        //somePromise() 返回promise对象
        function doSomethingSecond(resOfDoSomethingFirst) {
            return somePromise(); //有return， finalHandler接受到的是resOfDoSomethingSecond
            //somePromise();// 没有return， finalHandler接受到的是undefined
        }
        function finalHandler(resOfDoSomethingSecond) {
            // handle resOfDoSomethingSecond
        }

    示例：返回同步值 && 抛出一个同步错误
        返回同步值实际上是将同步代码转换为Promisey代码的一种很棒的方法。例如，假设我们有一个用户的内存缓存。我们可以做到：
        
            //getUserByName  和 getUserAccountById 都返回promise对象
            getUserByName("nolan").then(function (user) {
              if (user.isLoggedOut()) { //如果用户注销
                throw new Error("user logged out!"); // 抛出一个同步错误
              }
              if (inMemoryCache[user.id]) {
                return inMemoryCache[user.id];       //  返回一个同步值!
              }
              return getUserAccountById(user.id);    // 返回一个promise!
            }).then(function (userAccount) {
              // I got a user account!
            }).catch(function (err) {
              // Boo, I got an error!
            });
            
        如果用户注销，catch()将收到一个同步错误；通过callbacks，这个错误会被忽略
        如果任何promise被拒绝，catch()将收到一个异步错误。

通常情况下，一个promise 依赖于另一个promise ，但当我们需要两个promises的输出。我们该怎么做
    getUserByName("nolan").then(function (user) {
      return getUserAccountById(user.id);
    }).then(function (userAccount) {
      // 在这里我们已经获取到了用户账号userAccount，
      // 但是我们也需要user对象时该怎么做？
    });    

    解决方案：
    function onGetUserAndUserAccount(user, userAccount) {
      return doSomething(user, userAccount);
    }
    
    function onGetUser(user) {
      return getUserAccountById(user.id).then(function (userAccount) {
        return onGetUserAndUserAccount(user, userAccount);
      });
    }
    
    getUserByName("nolan")
      .then(onGetUser)
      .then(function () {
      // at this point, doSomething() is done, and we are back to indentation 0
    });

用于指定发生错误时的回调函数。catch 可以捕获
返回值：返回一个Promise，处理状态变为rejected的情况
参数：
    onRejected
        是一个函数，有一个参数，用来记录变成rejected状态返回的原因。
        当promise 状态变为rejected时被调用。

注意事项：
catch(rejectHandler) 
    等同于
.then(null, rejectHandler)或.then(undefined, rejectHandler)

但是 then(resolveHandler).catch(rejectHandler) 和then(resolveHandler, rejectHandler)
不是完全相同的。
区别在于：当使用then(resolveHandler, rejectHandler)格式时，如果resolveHandler本身抛出了错误，那么rejecthandler实际上不会捕获错误。所以更建议使用catch 而不是then的第二个参数。

示例：
    var p1 = new Promise((resolve, reject) => {
        resolve("one");
    });
    
    // catch函数中可以捕捉到resolveHandler 中的error并打印
    p1.then(function () {
        throw new Error("oh noes");
    }).catch(function (err) {
        console.log("err=", err); // Error: oh noes
    });
    
    // reject函数不能捕捉到resolveHandler中的error
    p1.then(function () {
        throw new Error("oh noes");
    }, function (err) {
        console.log("err=", err); 
    });

用于指定不管 Promise 对象最后状态如何，都会执行的操作

finally本质上是then方法的特例
promise
.finally(() => {
  // 语句
});

// 等同于
promise
.then(
  result => {
    // 语句
    return result;
  },
  error => {
    // 语句
    throw error;
  }
);
返回值：返回一个Promise，这个Promise对象设置了 finally 回调函数
参数：Promise 结束后调用的函数，onFinally 这个函数不接收任何参数，它仅用于无论最终结果如何都要执行的情况。所以finally方法里面的操作，不应依赖于 Promise 的执行结果。
示例：
    promise
    .then(result => {···})
    .catch(error => {···})
    .finally(() => {···});

用于将现有对象转为 Promise 对象
    new Promise(function (resolve, reject) {
      resolve(someSynchronousValue);
    }).then(/* ... */);
    等价于
    Promise.resolve(someSynchronousValue).then(/* ... */);

返回值：返回一个Promise 对象，这个Promise对象是被给定的值解析过的。
参数：
    value
        将被Promise对象解析的参数
        参数类型：
            Promise对象
            具有then方法的对象
            没有then方法的对象
            不带有任何参数

示例1：参数是一个Promise对象
    Promise.resolve将不做任何修改、原封不动地返回这个Promise对象

    var p = Promise.resolve([1,2,3]);
    console.log("p=", p); //"p=" [object Promise]
    console.log("p type= ", typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" Array [1, 2, 3]
      console.log("v type=",typeof(v)); //"v type=" "object"
    });
    
    var p2 =  Promise.resolve(p);
    console.log("p2=", p2); //"p2=" [object Promise]
    console.log("p2 type= ", typeof(p2)); //"p2 type= " "object"
    p2.then(function(v) {
      console.log("p2 v=",v); //"p2 v=" Array [1, 2, 3]
      console.log("p2 v type=",typeof(v)); //"p2 v type=" "object"
    });

    p2 == p
示例2：参数是一个具有then方法的对象
    返回的promise会采用这个thenable的对象的最终状态。

    let thenable = {
      then: function(resolve, reject) {
        resolve(42);
      }
    };
    
    let p = Promise.resolve(thenable);
    p.then(function(value) {
      console.log(value);  // 42
    });

    Promise.resolve方法会将thenable对象转为 Promise 对象，然后就立即执行thenable对象的then方法,thenable对象的then方法执行后，对象p的状态就变为resolved，从而立即执行最后那个then方法指定的回调函数，输出 42

示例3：参数是一个没有then方法的对象
    var p = Promise.resolve([1,2,3]);
    console.log("p=", p); //"p=" [object Promise]
    console.log("p type= ", typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" Array [1, 2, 3]
      console.log("v type=",typeof(v)); //"v type=" "object"
    });
    
    var p = Promise.resolve(123);
    console.log("p=", p); //"p=" [object Promise]
    console.log("p type= ", typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" 123
      console.log("v type=",typeof(v)); //"v type=" "number"
    });
    
    var p = Promise.resolve("123");
    console.log("p=", p); //"p=" [object Promise]
    console.log("p type= ", typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" "123"
      console.log("v type=",typeof(v)); //"v type=" "string"
    });

示例4：不带有任何参数
    var p = Promise.resolve();
    console.log("p=", p); //"p=" [object Promise]
    console.log("p type= ", typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" undefined
      console.log("v type=",typeof(v)); //"v type=" "undefined"
    });

注意事项：
    立即resolve()的 Promise 对象，是在本轮“事件循环”（event loop）的结束时执行，而不是在下一轮“事件循环”的开始时
        //在下一轮“事件循环”开始时执行
        setTimeout(function () { 
          console.log("three");
        }, 0);
        //在本轮“事件循环”结束时执行
        Promise.resolve().then(function () {
          console.log("two");
        });
        //立即执行
        console.log("one");
    结果：
        "one"
        "two"
        "three"        
            

返回值：返回一个Promise 对象，这个Promise 对象 带有状态是rejected的原因
参数：
    reason
        表示Promise被拒绝的原因
    new Promise(function (resolve, reject) {
      reject(someSynchronousReson);
    }).then(null,function(reason){
       //...
    });

等价于
    Promise.reject(someSynchronousReson)
    .then(null, function(reason) {
      //...
    });

    
示例:
    new Promise(function (resolve, reject) {
      reject("reject reason");
    }).then(null,function(reason){
            console.log(reason);//"reject reason"
    });
    
    Promise.reject("reject reason").then(null, function(reason) {
      console.log(reason); // "reject reason"
    });
    
    Promise.reject(new Error("reject reason")).then(null, function(error) {
      console.log(error); // Error: reject reason
    });

注意事项：与Promise.resolve不同的是Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。
    const thenable = {
      then(resolve, reject) {
        reject("出错了");
      }
    };
    
    Promise.reject(thenable)
    .catch(e => { //e不是reject抛出的“出错了”这个字符串，而是thenable对象。
      console.log(e === thenable) // true
    })

用于将多个 Promise 实例，包装成一个新的 Promise 实例
返回值：返回一个新的promise对象，iterable中所有的promise都变成resolved状态时返回的 promise才会变为resolved状态； iterable中有一个promise变成rejected状态，promise就会变为rejected状态。
参数：
    iterable
    一个可迭代对象，eg Array 或 String

示例： iterable中所有的promise都变成resolved状态时返回的 promise才会变为resolved状态
    var p1 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 1000, "one"); 
    }); 
    var p2 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 2000, "two"); 
    });
    var p3 = new Promise((resolve, reject) => {
      setTimeout(resolve, 3000, "three");
    });
    const p = Promise.all([p1, p2, p3]).then(values => { 
      console.log(values); //["one", "two", "three"]
    }).catch(reason => {
      console.log(reason); //没执行
    });

    流程：p创建时为pending状态，当p1, p2, p3的状态都变成resolved时触发p变成resolved状态。
    p1    1s
    |----------|resolved                      
    p2    2s 
    |--------------------|resolved
    p3    3s 
    |------------------------------|resolved
                                   p resolved
                                   

示例：iterable中有一个promise变成rejected状态，promise就会变为rejected状态
    var p1 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 1000, "one"); 
    }); 
    var p2 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 2000, "two"); 
    });
    var p3 = new Promise((resolve, reject) => {
      reject("reject");
    });
    const p = Promise.all([p1, p2, p3]).then(values => { 
      console.log(values); //没执行
    }).catch(reason => {
      console.log(reason); //"reject"
    });    

    流程：p创建时为pending状态，p3先执行完,p3的状态变成rejected时触发p变成rejected状态。
    p1    1s
    |----------|resolved                      
    p2    2s 
    |--------------------|resolved
    p3
    |-|rejected
      p rejected
      

示例：如果作为参数的 Promise 实例，自己定义了catch方法，那么它一旦被rejected，并不会触发Promise.all()的catch方法
    var p1 = new Promise((resolve, reject) => { 
          setTimeout(resolve, 1000, "one"); 
        }); 
        var p2 = new Promise((resolve, reject) => { 
          setTimeout(resolve, 2000, "two"); 
        });
        var p3 = new Promise((resolve, reject) => {
          reject("reject");
        }).catch(reason => {
          console.log(reason); //reject
        });
        const p = Promise.all([p1, p2, p3]).then(values => { 
          console.log(values); // ["one", "two", undefined]
        }).catch(reason => {
          console.log(reason); //没执行
        });    


    流程：p创建时为pending状态，p3先执行完,p3的状态变成rejected时，调用自己定义的catch函数抛出错误，不会触发p变成rejected状态。当p1 和 p2 也执行完时，触发p变成resolved状态
    p1    1s
    |----------|resolved                      
    p2    2s 
    |--------------------|resolved
    p3
    |-|rejected
                           |p resolved

示例：如果传入的参数是一个空的可迭代对象，则返回一个resolved状态的 Promise 
    const p = Promise.all([]).then(values => { //p创建时状态就为resolved
      console.log(values); // []
    });

同样是将多个 Promise 实例，包装成一个新的 Promise 实例
返回值：返回一个新的promise对象，一旦iterable中的某个promise变为resolved或rejected状态，返回的 promise就会变为resolved或rejected状态。谁最先执行完就返回谁的状态
参数：
    iterable
    一个可迭代对象，eg Array 或 String

示例： 一旦iterable中的某个promise变为resolved状态，返回的 promise就会变为resolved状态。
    var p1 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 1000, "one"); 
    }); 
    var p2 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 2000, "two"); 
    });
    var p3 = new Promise((resolve, reject) => {
      setTimeout(resolve, 3000, "three");
    });
    const p = Promise.race([p1, p2, p3]).then(values => { 
      console.log(values); //["one", "two", "three"]
    }).catch(reason => {
      console.log(reason); //没执行
    });

流程：p创建时为pending状态，p1先执行完，p1的状态都变成resolved时触发p变成resolved状态。
p1    1s
|----------|resolved
           p resolved                      
p2    2s 
|--------------------|resolved
p3    3s 
|------------------------------|resolved
                               
                                   
示例：一旦iterable中的某个promise变为rejected状态，返回的 promise就会变为rejected状态。
var p1 = new Promise((resolve, reject) => { 
  setTimeout(resolve, 1000, "one"); 
}); 
var p2 = new Promise((resolve, reject) => { 
  setTimeout(resolve, 2000, "two"); 
});
var p3 = new Promise((resolve, reject) => {
  reject("reject");
});
const p = Promise.all([p1, p2, p3]).then(values => { 
  console.log(values); //没执行
}).catch(reason => {
  console.log(reason); //"reject"
});    

流程：p创建时为pending状态，p3先执行完,p3的状态变成rejected时触发p变成rejected状态。
p1    1s
|----------|resolved                      
p2    2s 
|--------------------|resolved
p3
|-|rejected
  p rejected