Promise -- Async container & decorator

image

基本概念

Promise本质是用于承载异步操作的容器，使得异步操作能够以类似同步的面貌出现，所以then里面内容执行时机不要和其他同步代码做混淆。。
Promise（承诺）类比于将来一定会发生的事情，它本身有三个状态pending,resolved,rejected,当将来它的状态改变后，会调用注册的方法。

// Promise new出来之后就会立即执行，所以一般被包装在函数中，更易于理解调用时机。
const getJSON = function(url) {
  const promise = 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();

  });

  return promise;
};

异步函数内部，需要在合适的时机调用resolve或者reject，或者throw err（臣妾办不到异步正常完事儿呀~），以通知Promise改变自身状态。

then & catch

then接收传递resolve或者reject的参数，执行状态变化后的操作。
catch是then的子集，一般来说由then处理resolve，catch处理reject。
catch和then都会返回一个新的Promise对象，then将函数的返回值作为参数，新的promise的resolve会调用，实现链式调用。

post(...).then(res=>res.json()).then(json=>console.log(json))

应该与以下两个函数有关：
Promise.resolve();Promise.reject();

then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): Promise;

catch(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): Promise;

Promise.prototype.finally()

finally本质上是then方法的特例。
执行一个无参参数，不做其他任何修改。

Promise.prototype.finally = function (callback) {
  let P = this.constructor;
  return this.then(
    value  => P.resolve(callback()).then(() => value),
    reason => P.resolve(callback()).then(() => { throw reason })
  );
};

finally方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。该方法是 ES2018 引入标准的。
finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的 Promise 状态到底是fulfilled还是rejected。这表明，finally方法里面的操作，应该是与状态无关的，不依赖于 Promise 的执行结果。

Promise.all(),Promise.race()

异步的容器，自然可以放多个异步操作，从名字可以自解释。
接收一个promise对象的数组，如果不是promise对象，会对参数进行promise化。

Promise.resolve()，Promise.reject()

对于基本类型、函数、Promise的promise化。

resolve(value: T | PromiseLike): Promise;
reject(reason?: any): Promise;

js宽泛的、弱类型检查的语言，往往不需要其他语言重载等操作，但是使用起来安全性要尤其注意。

Promise.try()

际开发中，经常遇到一种情况：不知道或者不想区分，函数f是同步函数还是异步操作，但是想用 Promise 来处理它。因为这样就可以不管f是否包含异步操作，都用then方法指定下一步流程，用catch方法处理f抛出的错误。一般就会采用下面的写法。

Promise.resolve().then(f)

上面的写法有一个缺点，就是如果f是同步函数，那么它会在本轮事件循环的末尾执行。
那么有没有一种方法，让同步函数同步执行，异步函数异步执行，并且让它们具有统一的 API 呢？

// 不确定同步还是异步函数f，用async或者Promise包装，以同步调用方式使用
const f = (msg) => {
  console.log(msg)
  return msg
}

//Promise
(
  () => new Promise(
    resolve => resolve(f('In function F!'))
  )
)().then(msg=>console.log(msg)).catch(err=>console.log(err));

//async
(async () => f('hello in asyn'))()
  .then(msg => console.log(msg))
  .catch(err => console.log(err))
console.log('In code!')