node异步编程

同步API, 异步API

同步API：只有当前API执行完成后，才能继续执行下一个API

console.log('before'); 
console.log('after');

异步API：当前API的执行不会阻塞后续代码的执行

console.log('before');
setTimeout(
   () => { console.log('last');
}, 2000);
console.log('after');

同步API, 异步API的区别（ 获取返回值 ）

同步API可以从返回值中拿到API执行的结果, 但是异步API是不可以的

同步API, 异步API的区别（代码执行顺序）

同步API从上到下依次执行，前面代码会阻塞后面代码的执行
异步API不会等待API执行完成后再向下执行代码

使用回调函数获取异步API执行结果

function getMsg (callback) {
    setTimeout(function () {
        callback ({ msg: 'Hello Node.js' })
    }, 2000);
}
getMsg (function (msg) { 
    console.log(msg);
});

Node.js中的异步API

读取文件 requerst事件等等

回调地狱

例如依次读取三个文件

const fs = require('fs');
fs.readFile('./1.txt', 'utf8', (err, result1) => {
 console.log(result1)
 fs.readFile('./2.txt', 'utf8', (err, result2) => {
  console.log(result2)
  fs.readFile('./3.txt', 'utf8', (err, result3) => {
   console.log(result3)
  })
 })
});

会产生回调地狱

Promise

Promise出现的目的是解决Node.js异步编程中回调地狱的问题。
基础写法：

const fs = require('fs');
let promise = new Promise((resolve, reject) => {
    fs.readFile('./100.txt', 'utf8', (err, result) => {
        if (err != null) {
            //reject传递  失 败
            reject(err);
        } else {
            //resolve是个函数 将异步api的结果通过参数传输出去
            resolve(result);
        }
    });
});
//then方法传递成功结果  catch传递失败信息
promise.then((result) => {
        console.log(result);
    })
    .catch((err) => {
        console.log(err);
    })

使用promise依次调用三个文件

const fs = require('fs');
function p1 () {
 return new Promise ((resolve, reject) => {
  fs.readFile('./1.txt', 'utf8', (err, result) => {
   resolve(result)
  })
 });
}
function p2 () {
 return new Promise ((resolve, reject) => {
  fs.readFile('./2.txt', 'utf8', (err, result) => {
   resolve(result)
  })
 });
}
function p3 () {
 return new Promise ((resolve, reject) => {
  fs.readFile('./3.txt', 'utf8', (err, result) => {
   resolve(result)
  })
 });
}
p1().then((r1)=> {
 console.log(r1);
 return p2();
})
.then((r2)=> {
 console.log(r2);
 return p3();
})
.then((r3) => {
 console.log(r3)
})

异步函数

异步函数是异步编程语法的终极解决方案，它可以让我们将异步代码写成同步的形式，让代码不再有回调函数嵌套，使代码变得清晰明了。

async关键字

1. 普通函数定义前加async关键字 普通函数变成异步函数
2. 异步函数默认返回promise对象
3. 在异步函数内部使用return关键字进行结果返回 结果会被包裹的promise对象中 return关键字代替了resolve方法
4. 在异步函数内部使用throw关键字抛出程序异常 代替了reject
5. 调用异步函数再链式调用then方法获取异步函数执行结果
6. 调用异步函数再链式调用catch方法获取异步函数执行的错误信息
   await关键字
7. await关键字只能出现在异步函数中
8. await promise await后面只能写promise对象 写其他类型的API是不不可以的
9. await关键字可是暂停异步函数向下执行 直到promise返回结果

async function p1() {
    return 'p1';
}
async function p2() {
    return 'p2';
}
async function p3() {
    return 'p3';
}
async function run() {
    let r1 = await p1()
    let r2 = await p2()
    let r3 = await p3()
    console.log(r1)
    console.log(r2)
    console.log(r3)
}
run();

使用异步函数依次读取三个文件：

const fs = require('fs');
// 改造现有异步函数api 让其返回promise对象 从而支持异步函数语法
const promisify = require('util').promisify;
// 调用promisify方法改造现有异步API 让其返回promise对象
const readFile = promisify(fs.readFile);
async function run () {
 let r1 = await readFile('./1.txt', 'utf8')
 let r2 = await readFile('./2.txt', 'utf8')
 let r3 = await readFile('./3.txt', 'utf8')
 console.log(r1)
 console.log(r2)
 console.log(r3)
}
run();