异步编程的过去和现在（异步过程历史记录）

众所周知，javascript是单线程的. 它最初被设计为浏览器的GUI编程语言. GUI编程的功能之一是确保不要阻塞UI线程，否则体验会很差c 异步编程，甚至接口也会卡住.

所谓的“单线程”是指一次只能完成一个任务. 如果有多个任务，则必须排队，上一个任务完成，然后再执行后一个任务，依此类推.

下面是ABC的三个任务时同步或异步执行的流程图:

同步

> thread ->|----A-----||-----B-----------||-------C------|

异步

A-Start ---------------------------------------- A-End   
           | B-Start ----------------------------------------|--- B-End   
           |   |     C-Start -------------------- C-End      |     |   
           V   V       V                           V         V     V      
  thread-> |-A-|---B---|-C-|-A-|-C-|--A--|-B-|--C--|---A-----|--B--|

回调函数PromiseGeneratorcoasync，正在等待

下面将逐步显示各种方法.

　　function f1(callback){
　　　　setTimeout(function () {
　　　　　　// f1的任务代码
　　　　　　callback();
　　　　}, 1000);
　　}

缺点:

不利于代码的阅读和维护. 各个部分是高度耦合的. 这个过程将非常混乱. 每个任务只能指定一个回调函数. 无法捕获异常（try catch是同步执行的，回调函数将添加到队列中，并且无法捕获错误）

Promise不仅可以避免回调地狱，而且可以统一地捕获失败原因，并且现在也被广泛使用

  let promise = new Promise(function (resolve,reject) {
    resolve('wo')
});
promise.then(function (data) {
    return data +'shuai'
}).then(function (data) {
    console.log(data)
}).catch(function (err) {
    console.log(err)
});// woshuai

是需要添加*的函数. 它可用于生成迭代器. 功能不同于普通功能. 普通函数一旦被调用就会执行，但是函数可以在中间暂停. 不同于普通功能. 调用它不会立即执行. 它将返回此的迭代器. 迭代器是一个对象，每次调用next时都可以返回值对象.

function *go(a){
  console.log(1);
  //此处的b用来供外界输入进来的
  //这一行实现输入和输出，本次的输出放在yield后面，下次的输入放在yield前面
  let b =  yield a;
  console.log(2);
  let c = yield b;
  console.log(3);
  return c;
}
let it = go("a值");
//next第一次执行不需要参数，传参数没有意义
let r1 = it.next();
//第一次调用next会返回一个对象，此对象有两个属性，一个是value就是yield后面那个值，一个是done表示是否迭代完成
console.log(r1);//{ value: 'a', done: false }
let r2 = it.next('B值');
console.log(r2);//{ value: 'B值', done: false }
let r3 = it.next('C值');
console.log(r3);//{ value: 'C值', done: true }

随着前端的快速发展，伟大的上帝感到他们需要像同步代码一样异步编写. 公司出来了. co是TJ大神库c 异步编程，结合了诺言和. 实际上，它仍然可以帮助我们自动执行迭代器

let fs = require('fs');
function readFile(filename) {
  return new Promise(function (resolve, reject) {
    fs.readFile(filename, 'utf8', function (err, data) {
      err ? reject(err) : resolve(data);
    });
  })
}
function *read() {
  console.log('开始');
  let a = yield readFile('1.txt');
  console.log(a);
  let b = yield readFile('2.txt');
  console.log(b);
  let c = yield readFile('3.txt');
  console.log(c);
  return c;
}
function co(gen) {
  let it = gen();//我们要让我们的持续执行
  return new Promise(function (resolve, reject) {
    !function next(lastVal) {
        let {value,done} = it.next(lastVal);
        if(done){
          resolve(value);
        }else{
          value.then(next,reject);
        }
    }()
  });
}
co(read).then(function (data) {
  console.log(data);
});

异步等待是语法糖，在内部它是通过generator + promise实现的.

异步功能是将Generator函数的星号（*）替换为async，将yield替换为await

let Promise = require('bluebird');
let readFile = Promise.promisify(require('fs').readFile);
async function read() {
  //await后面必须跟一个promise,
  let a = await readFile('./1.txt','utf8');
  console.log(a);
  let b = await readFile('./2.txt','utf8');
  console.log(b);
  let c = await readFile('./3.txt','utf8');
  console.log(c);
  return 'ok';
}

setTimeout，process.nextTick，ajax，setImmediate都可以处理异步逻辑，下一篇文章EventLoop将被详细介绍.

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/ruanjian/article-276246-1.html