异步的进阶（callback > promise > async

建立一个promise-test文件夹
在文件夹中建立一个files文件，在该文件中建立三个文件a.json、b.json、c.json。

// a.json
{
    "next": "b.json",
    "msg": "this is a"
}

// b.json
{
    "next": "c.json",
    "msg": "this is b"
}

// c.json
{
    "next": "null",
    "msg": "this is b"
}

在promise-test文件中 建立index.js文件
要实现通过读取a.json文件的内容，如果有next值，就继续读取下个文件中的内容，以此类推。

第一中 callback

function getFileContent(fileName, callback) {
    const fullFileName = path.resolve(__dirname, 'files', fileName)
    fs.readFile(fullFileName, (err, data) => {
        if(err) {
            console.log(err)
            return 
        } 

        let require = JSON.parse(data.toString())
        callback(require)
    })
}

getFileContent('a.json', aData => {
    console.log(aData)
    getFileContent(aData.next, bData => {
        console.log(bData)
        getFileContent(bData.next, cData => {
            console.log(cData)
        })
    })
})

通过callback的形式去读取文件，容易形成地狱回调，是解决异步的传统解决方案。该方案一直被业界诟病，后来提出了promise解决方案。

promise 解决异步

function getFileContent (fileName) {
    let promise = new Promise((resolve, reject) => {
        let fullFileName = path.resolve(__dirname, 'files', fileName)
        fs.readFile(fullFileName, (err, data) => {
            if(err) {
                reject(err)
            }

            if (data) {
                resolve(
                    JSON.parse(data.toString())
                )
            }   
        })
    })

    return promise
}

getFileContent('a.json').then( aData => {
    return getFileContent(aData.next)
}).then(bData => {
    return getFileContent(bData.next)
}).then(cData => {
    return getFileContent(cData.next)
})

promise方案，通过 .then 来进行链式处理。看上去清爽了很多，不过还是有人觉得异步处理的不够彻底，增添了复杂性，又有人提了async await 方案，被很多人认为是异步处理的终极解决方案。

async await

async function readFileData() {
    try {
        let aData = await getFileContent('a.json')
        console.log(aData)
        let bData = await getFileContent(aData.next)
        console.log(bData)
        let cData = await getFileContent(bData.next)
        console.log(cData)
    } catch (err) {
        console.log(err)
    }
}
readFileData()

这种异步解决方案很受大家喜欢，用同步的写法来解决异步的处理。

async 的函数调用，返回的也是一个promise
async 和 await 必须得配合使用，await要写在async函数里
await 返回的是一个promise
通过 try catch 进行异常捕获，catch可以捕获到任意一个await里的异常，也就是promise的reject

递归的写法

function readJson (fileName) {
    let fullFileName = path.resolve(__dirname, 'files', fileName)
    fs.readFile(fullFileName, (err, data) => {
        if(err) {
            console.log(err)
            return 
        }

        if (data) {
            let require = JSON.parse(data.toString())
            console.log(require)
            if (require && require.next) {
                readJson(require.next)
            }
        } else {
            console.log('没有数据了')
            return 
        }
    })
}