异步

所谓”异步”，简单说就是一个使命分红两段，先实行第一段，然后转而实行其他使命，等做好了预备，再回过甚实行第二段,比方，有一个使命是读取文件举行处置惩罚，异步的实行历程就是下面如许。

这类不一连的实行，就叫做异步。响应地，一连的实行，就叫做同步。

高阶函数

函数作为一等国民，能够作为参数和返回值

能够用于批量天生函数

let toString = Object.prototype.toString;
let isString = function (obj) {
  return toString.call(obj) == `[object String]`;
}
let isFunction = function (obj) {
  return toString.call(obj) == `[object Function]`;
}
let isType = function (type) {
  return function (obj) {
    return toString.call(obj) == `[object ${type}]`;
  }
}

能够用于须要挪用屡次才实行的函数

let after = function(times,task){
  return function(){
    if(times--==1){
      return task.apply(this,arguments);
    }
  }
}
let fn = after(3,function(){
  console.log(3);});
fn();

异步编程的语法目的，就是如何让它更像同步编程,有以下几种

• 回调函数完成
• 事宜监听
• 宣布定阅
• Promise/A+ 和天生器函数
• async/await

回调

所谓回调函数，就是把使命的第二段零丁写在一个函数内里，比及从新实行这个使命的时刻，就直接挪用这个函数

fs.readFile('某个文件', function (err, data) {
  if (err) throw err;
  console.log(data);
});

这是一个毛病优先的回调函数(error-first callbacks),这也是Node.js自身的特性之一。

回调的题目

异常处置惩罚

try{
  //xxx
}catch(e){//TODO}
异步代码时try catch不再见效

let async = function(callback){
  try{
    setTimeout(function(){
      callback();
    },1000)
  }catch(e){
    console.log('捕捉毛病',e);
  }
}

async(function(){
  console.log(t);
});

由于这个回调函数被存放了起来，直到下一个事宜环的时刻才会掏出,try只能捕捉当前轮回内的异常，对callback异步无计可施。

Node在处置惩罚异常有一个商定，将异常作为回调的第一个实参传回，假如为空示意没有失足。

async(function(err,callback){
  if(err){
    console.log(err);
  }
});

异步要领也要遵照两个准绳

• 必须在异步以后挪用传入的回调函数
• 假如失足了要向回调函数传入异常供挪用者推断

let async = function(callback){
try{
  setTimeout(function(){
    if(success)
      callback(null);
    else
      callback('毛病');
  },1000)
}catch(e){
  console.log('捕捉毛病',e);
}
}

回调地狱

异步多级依靠的情况下嵌套异常深，代码难以浏览的保护

let fs = require('fs');
fs.readFile('template.txt','utf8',function(err,template){
fs.readFile('data.txt','utf8',function(err,data){
  console.log(template+' '+data);
})
})

异步流程处理方案

事宜宣布/定阅模子

定阅事宜完成了一个事宜与多个回调函数的关联

let fs = require('fs');
let EventEmitter = require('events');
let eve = new EventEmitter();
let html = {};
eve.on('ready',function(key,value){
  html[key] = value;
  if(Object.keys(html).length==2){
    console.log(html);
  }
});
function render(){
  fs.readFile('template.txt','utf8',function(err,template){
    eve.emit('ready','template',template);
  })
  fs.readFile('data.txt','utf8',function(err,data){
    eve.emit('ready','data',data);
  })
}
render();

尖兵变量

let fs = require('fs');

let after = function(times,callback){
  let result = {};
  return function(key,value){
    result[key] = value;
    if(Object.keys(result).length==times){
      callback(result);
    }
  }
}
let done = after(2,function(result){
  console.log(result);
});

function render(){
  fs.readFile('template.txt','utf8',function(err,template){
    done('template',template);
  })
  fs.readFile('data.txt','utf8',function(err,data){
    done('data',data);
  })
}
rende

Promise/Deferred形式

天生器Generators/ yield

当你在实行一个函数的时刻，你能够在某个点停息函数的实行，而且做一些其他事情，然后再返回这个函数继承实行， 以至是照顾一些新的值，然后继承实行。

上面形貌的场景恰是JavaScript天生器函数所致力于处理的题目。当我们挪用一个天生器函数的时刻，它并不会马上实行， 而是须要我们手动的去实行迭代操纵（next要领）。也就是说，你挪用天生器函数，它会返回给你一个迭代器。迭代器会遍历每一个中断点。
next要领返回值的value属性，是Generator函数向外输出数据next要领还能够接收参数，这是向 Generator 函数体内输入数据

天生器的运用

function* foo () {
  var index = 0;
  while (index < 2) {
    yield index++; //停息函数实行，并实行yield后的操纵
  }
}
var bar =  foo(); // 返回的实际上是一个迭代器

console.log(bar.next());    // { value: 0, done: false }
console.log(bar.next());    // { value: 1, done: false }
console.log(bar.next());    // { value: undefined, done: true }

Co

co是一个为Node.js和浏览器打造的基于天生器的流程掌握东西，借助于Promise，你能够运用越发文雅的体式格局编写非壅塞代码。

let fs = require('fs');
function readFile(filename) {
  return new Promise(function (resolve, reject) {
    fs.readFile(filename, function (err, data) {
      if (err)
        reject(err);
      else
        resolve(data);
    })
  })
}
function *read() {
  let template = yield readFile('./template.txt');
  let data = yield readFile('./data.txt');
  return template + '+' + data;
}
co(read).then(function (data) {
  console.log(data);
}, function (err) {
  console.log(err);
});
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, reason => reject(reason));
      }
    }();
  });
}

Async/ await

运用async关键字，你能够轻松地杀青之前运用天生器和co函数所做到的事情

Async的长处

• 内置实行器
• 更好的语义
• 更广的适用性

let fs = require('fs');
function readFile(filename) {
  return new Promise(function (resolve, reject) {
    fs.readFile(filename, 'utf8', function (err, data) {
      if (err)
        reject(err);
      else
        resolve(data);
    })
  })
}

async function read() {
  let template = await readFile('./template.txt');
  let data = await readFile('./data.txt');
  return template + '+' + data;
}
let result = read();
result.then(data=>console.log(data));

async 函数的完成

async 函数的完成，就是将 Generator 函数和自动实行器，包装在一个函数里。

async function read() {
  let template = await readFile('./template.txt');
  let data = await readFile('./data.txt');
  return template + '+' + data;
}

// 等同于
function read(){
  return co(function*() {
    let template = yield readFile('./template.txt');
    let data = yield readFile('./data.txt');
    return template + '+' + data;
  });
}
async_function- generator