Vue学习——同步、异步读取文件、Promise应用

Buffer:

var arr = Buffer.from([3, 6, 9, 15]);
// 转成16进制0-9，a-f：10-15
console.log(arr);
// 转成16进制，
let buf = Buffer.from("node.js");
console.log(buf);
// 要看书buffer，要用toString()进行转化
console.log(buf.toString());

同步：一个文件一个文件的运行，后面的文件要等前面的文件执行完毕后才可以运行

异步：多个文件同时运行。

需要多个文件运行时：同步比异步慢

在当前目录下创建三个.txt文件

回调地狱：是一种现象，不是错误

let fs = require("fs");
let path = require("path");
let urla = path.join(__dirname, "aa.txt");
let urlb = path.join(__dirname, "bb.txt");
let urlc = path.join(__dirname, "cc.txt");
// 这样写会出现读取顺序出错，错乱
fs.readFile(urla, "utf-8", function (error, data) {
    console.log(data);
})
fs.readFile(urlb, "utf-8", function (error, data) {
    console.log(data);
})
fs.readFile(urlc, "utf-8", function (error, data) {
    console.log(data);
})
// 这样利用回调函数可以使读取顺序不会乱，但是嵌套很多，不会维护——回调地狱，这不是一种错误，是一种现象
// fs.readFile(urla, "utf-8", function (error, data) {
//     console.log(data);
//     fs.readFile(urlb, "utf-8", function (error, data) {
//         console.log(data);
//         fs.readFile(urlc, "utf-8", function (error, data) {
//             console.log(data);
//         })
//     })
// })

Promise：是异步编程的一种解决方案，是一个对象，提供API。

let fs = require("fs");
let path = require("path");
let url = path.join(__dirname, "aa.txt");
// res, rej是两个函数
// new出来的都是个构造函数
//res, rej是自定义的函数名，res：读取成功的函数；rej读取失败的函数
let p = new Promise(function (res, rej) {
    fs.readFile(url, "utf-8", function (error, data) {
        // 若是读取失败rej函数带出error
        //读取成功error为null，为true
        if (error) {
            rej(error);
            return;
        } else {
            // 读取成功带出读取到的数据
            res(data);
        }
    })
})
// .then()里面可以放两个形参（函数）,位置没有要求
p.then(
    // res:成功的
    function (error) {
        console.log(error);
    }, function (data) {
        // rej：错误的
        console.log(data);
    }
)

error返回null时，说明读取成功；

Promise

Promise综合1.0

let fs = require("fs");
let path = require("path");
let urla = path.join(__dirname, "aa.txt");
let urlb = path.join(__dirname, "bb.txt");
let urlc = path.join(__dirname, "cc.txt");


// p1()返回获取的是一个Promise对象
// function p1() {
//     // 直接返回Promise对象
//     return new Promise((res, rej) => {
//         fs.readFile(urla, "utf-8", (err, data) => {
//             if (err) {
//                 rej(err);
//                 return;
//             };
//             res(data);
//         });
//     });
// };
// function p2() {
//     // 直接返回Promise对象
//     return new Promise((res, rej) => {
//         fs.readFile(urlb, "utf-8", (err, data) => {
//             if (err) {
//                 rej(err);
//                 return;
//             };
//             res(data);
//         });
//     });
// };
// function p3() {
//     // 直接返回Promise对象
//     return new Promise((res, rej) => {
//         fs.readFile(urlc, "utf-8", (err, data) => {
//             if (err) {
//                 rej(err);
//                 return;
//             };
//             res(data);
//         });
//     });
// };

// 要先执行函数有返回才可以使用.then
/* p1().then((data) => {
    console.log(data);
    // p2()返回的是一个Promise对象，但这里是.then的链式做法，所以这里面返回的是promise对象内部调用resolve时候的实际参数data
    // 下一个then接受的是p2()内Promise对象的data，而不是Promise对象
    return p2();
}).then((data) => {
    console.log(data);
    return p3();
}).then((data) => {
    console.log(data);
}) */

//优化版，封装p1(),p2(),p3(),这三个函数只有路径不一样其他都一样，所以把路径当做形参，
function readFiles(path) {
    return new Promise((res, rej) => {
        fs.readFile(path, "utf-8", (err, data) => {
            if (err) {
                rej(err);
                return;
            };
            res(data);
        });
    });
}
readFiles(urla).then((data) => {
    console.log(data);
    return readFiles(urlb);
}).then((data) => {
    console.log(data);
    return readFiles(urlc);
}).then((data) => {
    console.log(data);
})

Promise综合2.0

这三个都是node的内置模块

let fs = require("fs");
let path = require("path");
let util = require("util");

util.promisify()版本

let fs = require("fs");
let path = require("path");
let util = require("util");
let urla = path.join(__dirname, "aa.txt");
let urlb = path.join(__dirname, "bb.txt");
let urlc = path.join(__dirname, "cc.txt");
// 读文件，readF是一个方法
// 参数是异步读取文件
var readF = util.promisify(fs.readFile);
// 第一个参数是路径，第二个参数是数据显示方式，若不写utf-8，则显示的方式是Buffer样式，需要用toString()转换
readF(urla, "utf-8")
    .then((data) => {
        console.log(data);
        return readF(urlb, "utf-8");
    }).then((data) => {
        console.log(data);
        return readF(urlc, "utf-8");
    }).then((data) => {
        console.log(data);
    });

Promise综合3.0

.all()版本

let fs = require("fs");
let path = require("path");
let util = require("util");
let urla = path.join(__dirname, "aa.txt");
let urlb = path.join(__dirname, "bb.txt");
let urlc = path.join(__dirname, "cc.txt");
// 读文件，readF是一个方法
// 参数是异步读取文件
var readF = util.promisify(fs.readFile);
// 第一个参数是路径，第二个参数是数据显示方式，若不写utf-8，则显示的方式是Buffer样式，需要用toString()转换
/* readF(urla, "utf-8")
    .then((data) => {
        console.log(data);
        return readF(urlb, "utf-8");
    }).then((data) => {
        console.log(data);
        return readF(urlc, "utf-8");
    }).then((data) => {
        console.log(data);
    }); */

// .all()里面放的是数组，返回的data也是一个数组，所以用下标的方式获取值
Promise.all([
    readF(urla, "utf-8"),
    readF(urlb, "utf-8"),
    readF(urlc, "utf-8"),
]).then((data) => {
    // data：[ '', '', '' ]
    console.log(data[0]);
    console.log(data[1]);
    console.log(data[2]);
})

Promise综合3.0——终极版

let fs = require("fs");
let path = require("path");
let util = require("util");
let urla = path.join(__dirname, "aa.txt");
let urlb = path.join(__dirname, "bb.txt");
let urlc = path.join(__dirname, "cc.txt");

// .promisify()里面自己创建了Promise对象
var readF = util.promisify(fs.readFile);

// async和await的做法
// async放在function前面
// await放在function里面
async function fnc() {
    // await后面接的一定要是Promise对象
    var aa = readF(urla, "utf-8");      //Promise { <pending> }
    console.log(aa);
    var data1 = await readF(urla, "utf-8");
    var data2 = await readF(urlb, "utf-8");
    var data3 = await readF(urlc, "utf-8");
    console.log(data1);
    console.log(data2);
    console.log(data3);
}
// 记得调用
fnc();