Javascript自学随笔：Promise & Async

Promise

一个有限状态机，三个状态，输入一个函数，输出异步操作的结果。状态机本身同步执行，函数异步执行。

缺点

1.无法取消Promise，一旦新建它就会立即执行，无法中途取消。
2.如果不设置回调函数，Promise内部抛出的错误，不会反应到外部。
3.当处于pending状态时，无法得知目前进展到哪一个阶段
Promise State:
Pending, Resolved, Rejected.

执行函数

初始化promise，定义状态控制逻辑。
eg.

let p = new Promise((res, rej)=>{
  setTimeout(reject,10000);}) //超时停止
setTimeout(console.log, 0, p) //查看promise状态

Promise.resolve()

let p = Promise.resolve(arg);
初始化Promoise在resolved状态。argument可以是任意值，会被pass进p里，wrap成resolved promise。
Promise.reject(arg):
区别是arg会被当作reason直接被返回。是promise时，promise对象会被返回，而不是一个resolved promise。

then

p.then(()=>onResolve(‘p’),()=> onReject(‘p’));
catch: 等价then(null,rej=>{})
一般来说，每个promise后面都需要catch exception，所以不要在then()方法里面直接定义 Reject 状态的回调函数，总是使用catch+then方法。
fianlly: 等价then(res=>{{…}return res},rej=>{{…}return rej} ), reject和resolve都执行，一般用来扫尾工作。

不可重入性

这些方法里的函数，会在同步代码执行结束后开始执行。串联的方法里，异步内容是按串联顺序执行的。

Parallel Promise Composition

all: 只有all()里全部的promise resolve，all才会resolve。只要有1个reject，all就会reject。
race:只有race()里全部的promise reject，race才会reject。只要有1个resolve，race就会resolve。
allsettled:只要全部返回结果，就resolve。永远不会reject。ES2020

Serial Promise Composition

老办法：
function compose(…fns){
return x => { fns.reduce((promise, fn) =>promise.then(fn), Promise.resolve(x))}
let composition = compose(p1, p2, p3)
composition(input);
新办法：async 来了。让同步函数同步执行，异步函数异步执行，并且让它们具有统一的 API 。

*面试八股 - 手动默写promise

https://zhuanlan.zhihu.com/p/144058361
https://www.cnblogs.com/jzhishu/p/13595001.html

Async Functions

Generator

函数内实现暂停功能。语法为function后带*,或函数名前带*。
yield: key word, 暂停执行。直接当变量用等同于input。接在return后表示output。yield*返回iterable(可迭代对象)。
return: gfn.return(x)，立刻终止generator并返回x。
throw: 注入一个自定义error，如果generator处理了error，无视当前yield但继续运行；如果没处理error，generator进入停止状态。

Async

async，本质是Generator的语法糖。async函数的返回值是 Promise 对象，这比 Generator 函数的返回值是 Iterator 对象方便多了。你可以用then方法指定下一步的操作。

await

等待表达式resolve再继续。非promise类会被包装成promise，所以async可以用于异步和同步逻辑。await后promise出错等同于async function出错，如果想内部处理用try catch，也可用.catch。await和promise用的是两个不同信息队列,await优先级高于promise,当然优先级最高还是同步代码.利用这点,我们可以写一个sleep()函数,使得异步操作有个delay但又不影响同步代码的运行.
async function sleep(t){
return new Promise(res => setTimeout(res, t));}

Async并行/串行

并行执行异步代码：因为Promise实例化后立刻执行，所以并行要点先完成实例化再await实例。
串行执行异步代码：反过来，await每个Promise实例化，就可以串行执行每个promise了。

*面试八股 - 手动默写async

//定义自动执行器，自动执行generator function，返回结果封装入promise
function spawn(genF) {
  return new Promise((resolve, reject) => {
    //自动遍历的迭代实现，迭代核心为gen.next。
    function step(nextF) {
      let next = nextF();
      //暂停条件，如果到iterator末尾就resolve
      if(next.done) {
        return resolve(next.value);
      }
      //否则，继续执行下一个yield后的内容。.then()内是迭代核心gen.next和gen.throw。
      Promise.resolve(next.value)
      .then(
          v => {step(() => gen.next(v));},
          e => {step(() => gen.throw(e));}
      );
    }
    
    const gen = genF();//得到初始iterator
    step(() =>  gen.next());//输入初始iterator，开始遍历
  });
}

function fn(args) {
 //你的自定义函数a()
  function* a() {
    //你的代码。yield代替await。
  }
//运行自动执行器
  return spawn(a);
}

//运行！
let g=fn();

*内存管理

简单来说就是实例化promise的时候在js引擎会额外创建一个call stack，这个stack会保存回调函数直到promise resolve/reject。当error出现时，promise内的回调函数可以被调用出来。在async里，await new Promise()直接运行回调函数等结果，不会额外浪费空间将其保存在call stack里。
原文：