Node相关知识-try{}catch(){}、异步读写文件、Promise

Node

.join:用来拼接地址

*var* bb = path.join(__dirname, 'a', 'b', 'c');

结果：

C:\Users\Lenovo\Desktop\node\a\b\c

try{}catch(){}

const fs = require("fs");
const path = require("path");

var bb = path.join(__dirname, 'a', 'b', 'c');
// console.log(bb);
// console.log(bb);
// 回调函数的两个参数可以自定义，但是位置意义是固定的
// 第一个参数是错误信息（若error返回Null，表示读取成功，若是一个对象，则表示读取失败）
// 第二个参数是读取到的数据
fs.readFile(path.join(__dirname, 'aa.txt'), 'utf-8', function(error, data) {
    // try{}catch{}用来捕获错误信息的
    // 若try里面语句都是对的就不执行catch里面的语句，
    // 语句一行一行的执行，try里面有一个语句出错了，就会中断，执行catch里面的代码。出错语句后面的代码都不会执行了
    try {
        console.log(data);
        console.log(aaa);
    } catch (errMsg) {
        // errMsg是错误信息
        console.log(errMsg);
        // aaa is not defined
    }
})

判断

const fs = require("fs");
const path = require("path");

// 回调函数的两个参数可以自定义，但是位置意义是固定的
// 第一个参数是错误信息（若error返回Null，表示读取成功，若是一个对象，则表示读取失败）
// 第二个参数是读取到的数据
fs.readFile(path.join(__dirname, 'aa.txt'), 'utf-8', function(error, data) {
     
    // 若是读取数据成功，error为null，,则执行else里面的代码，输出读取到的数据
    // 若是读取失败，则输出'读取文件失败'，并终止函数
    if (error) {
     
        console.log('读取文件失败');
        // return用在函数里面
        // 若是读取文件失败，return返回一个数据，终止函数，跳出函数不再执行函数后续的代码
        return;
    } else {
     
        console.log(data);
    }

})

// 异步读取文件
var newData = 1234;
fs.readFile(pathA, 'utf-8', function(err, data) {
     
    newData = data;
    console.log(newData);
})
console.log(newData);

输出结果：

1234
我是aa.txt的文本内容

因为是异步读取文件，所以**fs.readFile()在读取的同时，另外的console.log(newData);**也在执行，**fs.readFile()的回调函数是后面才执行的，而console.log(newData);的执行比fs.readFile()**的执行快，所以先输出1234，后输出读取到的数据

异步写入文件：

产生回调地狱

回调地狱缺点：代码臃肿；可读性差；耦合度过高，可维护性差；代码复用性差；容易滋生bug；只能在回调里处理异常。

const fs = require("fs");
const path = require("path");
const pathA = path.join(__dirname, 'aa.txt');
const pathB = path.join(__dirname, 'bb.txt');
const pathC = path.join(__dirname, 'cc.txt');
// 异步写入文件，写入文件的回调函数参数只有一个————错误信息
/* fs.writeFile(pathA, '我是aa.txt的文本内容', function(err) {
    if (!err) {
        console.log('写入文件成功');
    }
}) */
// 异步读取文件:
// 将aa.txt的文本内容与bb.txt的文本内容进行拼接，再写入bb.txt中，bb.txt的内容更新；
// 将bb.txt的文本内容和cc.txt的文本内容进行拼接，写入cc.txt中
// 异步读取aa.txt文件内容
fs.readFile(pathA, 'utf-8', function(err, data) {
    // 将aa.txt的文本内容赋给newData
    var newData = data;
    console.log('aa.txt的文本内容为：' + data);
    // 异步读取bb.txt的文本内容
    fs.readFile(pathB, 'utf-8', function(err, data) {
        // 将aa.txt的内容和bb.txt的内容拼接赋给newData
        newData = newData + data;
        console.log('bb.txt的文本内容为：' + data);
        // 异步写入：将拼接后的内容newData异步写入bb.txt，
        fs.writeFile(pathB, newData, function(err) {
            console.log('bb.txt修改后的文本内容为：' + newData);
            // 异步读取cc.txt的内容
            fs.readFile(pathC, 'utf-8', function(err, data) {
                console.log('cc.txt的文本内容为：' + data);
                // 将aa.txt的内容和bb.txt的内容拼接而成的newData再与cc.txt的内容data拼接
                //再次赋给newData，newData的值为三个txt文本拼接的结果
                newData = newData + data;
                // 异步写入文件：将最后拼接的结果写入cc.txt中
                fs.writeFile(pathC, newData, function(err) {
                    console.log('cc.txt修改后的文本内容为：' + newData);
                })
            })
        })
    })
})



/* fs.readFile(pathA, 'utf-8', function(errorA, dataA) {
    if (!errorA) {
        console.log(dataA);
        fs.writeFile(pathB, dataA, function(errorB) {
            if (!errorB) {
                console.log('写入数据成功');
                fs.readFile(pathC, 'utf-8', function(errorC, dataC) {
                    if (!errorC) {
                        console.log(dataC);
                        return;
                    } else {
                        console.log('读取文件失败');
                    }
                })
            } else {
                console.log('写入文件失败');
            }
        })
    } else {
        console.log('读取文件失败');
    }
}) */

Promise

Promise是异步编程（回调地狱）的一种解决方案，现已被纳入ES6规范中。Promise是一个回调函数。

特点：

1.对象的状态不受外界影响；

状态：

pending（进行中）

fulfilled（已成功）

rejected（已失败）

2.一旦状态改变，就不会再变，任何时候都可以得到这个结果

// resolve, reject两个参数是两个函数,用来带出数据信息的
// resolve：带出正确信息回调函数, reject：带出错误信息的函数
var p = new Promise(function(resolve, reject) {
    reject('我是错误的');
});
// 第一个是正确的，第二个是错误的
p.then(function() {

}, function() {

})

基础版Promise1.0

let fs = require('fs');
let path = require('path');
let aPath = path.join(__dirname, 'aa.txt');


// 用Promise里面的两个resolve, reject函数，将异步读取到的文件带出
var p = new Promise(function(resolve, reject) {
    fs.readFile(aPath, 'utf-8', function(err, data) {
        if (!err) {
            resolve(data);
            return;
        }
        reject(err);
    })
});
// console.log(p); //正在进行中
// .then():将异步读取到的文件输出
p.then(
    //正确的回调函数:resolve，带出读取的数据
    function(data) {
        console.log(data);
    },
    //错误的回调函数:reject，带出错误信息
    function(err) {
        console.log(err);
    }
)

进阶版2.0：

const fs = require("fs");
const path = require("path");
const pathA = path.join(__dirname, 'aa.txt');
const pathB = path.join(__dirname, 'bb.txt');
const pathC = path.join(__dirname, 'cc.txt');
// return的是一个Promise对象
function p1() {
    return new Promise(function(resolve, reject) {
        fs.readFile(pathA, 'utf-8', function(err, data) {
            // 若读取数据成功，err为null，布尔值为false,!null为true,执行resolve(data)，带出读取到的data，终止函数
            if (!err) {
                resolve(data);
                return;
            }
            reject(err);
        })
    })
}

function p2() {
    return new Promise(function(resolve, reject) {
        fs.readFile(pathB, 'utf-8', function(err, data) {
            if (!err) {
                resolve(data);
                return;
            }
            reject(err);
        })
    })
}

function p3() {
    return new Promise(function(resolve, reject) {
        fs.readFile(pathC, 'utf-8', function(err, data) {
            if (!err) {
                resolve(data);
                return;
            }
            reject(err);
        })
    })
}

// 不想显示错误信息，就把reject函数删掉
p1().then(
    // 这个函数相当于调用了resolve()
    function(data) {
        console.log(data);
        return p2();
    },
    // 这个函数相当于调用了reject()
    function(err) {
        console.log(err);
    }
).then(
    // 这里是调用p2()中的resolve()
    function(data) {
        console.log(data);
        return p3();
    }
).then(
    // 这里是调用p3()中的resolve()
    function(data) {
        console.log(data);
    }
)

// async是放在函数前面
// await后面加的是Promise对象
async function test() {
    var aa = await p3();
};