理解 Nodejs 异步

在代码的执行过程中，每遇到一个异步函数，都会将这个异步函数放入一个异步队列当中，只有当同步线程执行结束之后，才会开始执行异步队列中的函数

常见的异步函数：readFile(), 定时器、事件

异步读取文件

var fs = require('fs')
console.log('文件开始读取')
fs.readFile('a.txt','utf8', (err, data) => {
    console.log(data)
})
console.log('文件读取结束')

输出结果是

文件开始读取
文件读取结束
aaaaaa

setTimeout(function(){
    console.log(1)
},0);
console.log('2')

执行结果是

2
1

虽然定时器的等待时间设置为0，其中的function也会被放入一个任务队列中，等待后面代码执行完之后执行

当执行文件操作：比如依次读取A文件、B文件、C文件

const fs = require('fs')
const path = require('path')
let a_path = path.join(__dirname, 'file', 'a.txt')
let b_path = path.join(__dirname, 'file', 'b.txt')
let c_path = path.join(__dirname, 'file', 'c.txt')

fs.readFile(a_path, 'utf8', (err, data) => {
    if (err) throw err
    console.log(data)
    fs.readFile(b_path, 'utf8', (err, data) => {
        if (err) throw err
        console.log(data)
        fs.readFile(c_path, 'utf8', (err, data) => {
            if (err) throw err
            console.log(data)

        })
    })
})

当你使用回调函数写完会发现形成了**回调地狱 **（层层嵌套，可读性差）
解决回调地狱的方法：Promise:
promise:承诺将来会执行
promise有两个参数：

1. resolve:未完成转向完成
2. reject：未完成转向失败

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

将重复的代码封装到一个函数中，需要时直接调用，这样看起来代码逻辑更清除没有太多的嵌套层次

调用then()方法调用当前实例状态发生改变时的回调函数。返回一个新的Promise实例