node_promise常用方法

// Promise 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大
// 所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果
// 
// 两个特点
// 1.对象的状态不受外界影响。Promise对象代表一个异步操作，
//   有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。
//   只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。
// 2.一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，
//   只有两种可能：从pending变为fulfilled和从pending变为rejected。
//   只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为 resolved（已定型）。
//   如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。
//   这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
   
// Promise也有一些缺点。首先，无法取消Promise，一旦新建它就会立即执行，无法中途取消。
// 其次，如果不设置回调函数，Promise内部抛出的错误，不会反应到外部。
// 第三，当处于pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）。

// ES6 规定，Promise对象是一个构造函数，用来生成Promise实例。
// 构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject函数，封装在promise对象里
const promise = new Promise(function(resolve, reject) {
  // ... some code
  if (/* 异步操作成功 */ true){
    // 将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved）
    // 在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；
    // console.log('Promise'); ==========> 第一次打印
    // 调用resolve或reject并不会终结 Promise 的参数函数的执行。
    return resolve(value);
    //console.log(22) 继续执行
    //一般来说，调用resolve或reject以后，Promise 的使命就完成了，
    //后继操作应该放到then方法里面，而不应该直接写在resolve或reject的后面。
    //所以，最好在它们前面加上return语句，这样就不会有意外。
  } else {
    // 将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），
    // 在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。
    reject(error);
  }
});

// Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。
// 第一个回调函数是Promise对象的状态变为resolved时调用
// 第二个回调函数是Promise对象的状态变为rejected时调用。可选
// 将promise传出的值作为参数接收
promise.then(function(value) {
  // success
  // console.log('resolved.');
  return 'test'
}, function(error) {
  // failure
  // console.log(error) ==========> 最后一次打印
})
  // promise 方法外 console.log('first') ==========> 第二次打印
.then(data=> {
  // Promise.prototype.then() then方法是定义在原型对象Promise.prototype上的
  // then方法的第一个参数是resolved状态的回调函数，第二个参数（可选）是rejected状态的回调函数。
  // then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。
  // 因此可以采用链式写法，即then方法后面再调用另一个then方法。
  console.log('链式语法,是上一个then方法的返回值',data) //==> 'test'
  // throw new Error('test'); 抛出错误 //被catch捕获
  })
.catch(err => {
  // Promise.prototype.catch方法是.then(null, rejection)
  // 或.then(undefined, rejection)的别名，用于指定发生错误时的回调函数。
  // then方法指定的回调函数，如果运行中抛出错误，状态就会变为rejected,也会被catch方法捕获。
  // 如果 Promise 状态已经变成resolved，再抛出错误是无效的。
  // const promise = new Promise(function(resolve, reject) {
  //   resolve('ok');
  //   throw new Error('test');
  // });
  // promise
  // .then(function(value) { console.log(value) })
  // .catch(function(error) { console.log(error) });
  // ===> ok
  // Promise 在resolve语句后面，再抛出错误，不会被捕获，等于没有抛出。
  // 因为 Promise 的状态一旦改变，就永久保持该状态，不会再变了。
  // Promise 对象的错误具有“冒泡”性质，会一直向后传递，
  // 直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。
  // getJSON('/post/1.json').then(function(post) {
  //   return getJSON(post.commentURL);
  // }).then(function(comments) {
  //   // some code
  // }).catch(function(error) {
  //   // 处理前面三个Promise产生的错误
  // });
  // 一般来说，不要在then方法里面定义 Reject 状态的回调函数（即then的第二个参数），总是使用catch方法。
  // catch方法返回的还是一个 Promise 对象，因此后面还可以接着调用then方法。
  // 此时，要是then方法里面报错，就与前面的catch无关了。
  console.log(err)
})
.finally(()=> {
  // Promise.prototype.finally() 
  // finally方法用于指定不管 Promise 对象最后状态如何，
  // 在执行完then或catch指定的回调函数以后，都会执行finally方法指定的回调函数
  // finally方法的回调函数不接受任何参数，这意味着没有办法知道，
  // 前面的 Promise 状态到底是fulfilled还是rejected。
  // 这表明，finally方法里面的操作，应该是与状态无关的，不依赖于 Promise 的执行结果
})

// 异步图片记载封装
function loadImageAsync(url) {
  return new Promise(function(resolve, reject) {
    const image = new Image();
    image.onload = function() {
      resolve(image);
    };

    image.onerror = function() {
      reject(new Error('Could not load image at ' + url));
    };
    image.src = url;
  });
}
loadImageAsync('http://......')

// Promise对象实现的 Ajax 封装
const getJSON = function(url) {
  return new Promise(function(resolve, reject){
    const handler = function() {
      if (this.readyState !== 4) return;
      if (this.status === 200) resolve(this.response);
      else reject(new Error(this.statusText));
    };
    const client = new XMLHttpRequest();
    client.open("GET", url);
    client.onreadystatechange = handler;
    client.responseType = "json";
    client.setRequestHeader("Accept", "application/json");
    client.send();
  });
};
getJSON("http://..........")
  .then(function(json) {
    console.log('ContentsAjax: ', json);
    return json.slice(json.length-1)
  }, function(error) {
    console.error('出错了', error);
  })
  


// resolve函数的参数除了正常的值以外，还可能是另一个 Promise 实例
// reject函数的参数通常是Error对象的实例，表示抛出的错误

// p1是一个 Promise，3 秒之后变为rejected
const p1 = new Promise(function (resolve, reject) {
  setTimeout(() => reject(new Error('fail')), 3000)
})
// p2的状态在 1 秒之后改变，resolve方法返回的是p1
// 由于p2返回的是另一个 Promise，导致p2自己的状态无效了，由p1的状态决定p2的状态
// 所以，后面的then语句都变成针对后者（p1）。
// 又过了 2 秒，p1变为rejected，导致触发catch方法指定的回调函数。
const p2 = new Promise(function (resolve, reject) {
  setTimeout(() => resolve(p1), 1000)
})

p2
.then(result => console.log(result))
.catch(error => console.log(error))
// => error: fail