NodeJS_文件系统_4

一、Buffer缓冲区

/**
 *  Buffer(缓冲区)
 *      -Buffer的结构和数组很像，操作的方法也和数组类似
 *      - 数组中不能存储二进制的文件，而buffer就是专门存储二进制数
 *      - 在buffer中存储的都是二进制数据，但是在显示时都是以16进制的形式显示
 *          buffer中每一个元素的范围是从00-ff 0-255
 *          00000000 - ffffffff
 *
 *          计算机 一个0 或一个1 称为1位（bit）
 *          8bit = 1byte(字节)
 *          buffer中的一个元素，占用内存的一个字节
 *
 *          buf2[10] = 22; 下面是问题说明
 *          -Buffer的大小一旦确定，则不能修改，Buffer实际上是底层对内存的直接操作
* */

var str = "Hello 世界";

//讲一个字符串保存到buffer中
var buf = Buffer.from(str);

console.log(buf.length); //内存占用的大小
console.log(str.length);//字符串的长度

console.log(buf);

//创建一个指定大小的buffer
buffer构造函数都是不推荐使用的
var buf2 = new Buffer(10); //10个字节的buffer
console.log(buf2.length);

//创建一个10个字节的buffer
var buf2 = Buffer.allc(10);
//通过索引，来操作buf的元素
buf2[0] = 88;
buf2[1] = 255;
buf2[2] = 0xaa;
buf2[10] = 22;
buf2[3] = 566  //超过了255范围存储到内存中会被舍弃
console.log(buf2);

//只要数字在控制台或页面中输出一定是10进制
console.log(buf2[2]);
//转换成16进制
console.log(buf2[2].toString(16));


var buf3 = Buffer.alloc(10);
console.log(buf3);

//Buffer.allocUnsafe(size) 创建一个指定大小的buffer,但是buffer中可能含有敏感数据
var buf4 = Buffer.allocUnsafe(10);
console.log(buf4);

/**
 *  Buffer.from(str) 将一个字符串转换为buffer
 *  Buffer.alloc(size) 创建一个指定大小的Buffer
 *  Buffer.allocUnsafe(size) 创建一个指定大小的Buffer,但是可能包含敏感信息
 *  buf.toString() 将缓冲区的数据转换成字符串
 */
var buf5 = Buffer.from("我是一段文本数据");
//将buffer转换成字符串
console.log(buf5.toString());

二、同步文件的写入

/**
*   文件系统（File System）
 *      - 文件系统简单来说是通过Node来操作系统中的文件
 *      - 使用文件系统，需要先引入fs模块，fs是核心模块，直接引入不需要下载
 *
 *  同步文件写入
 *      - 手动操作的步骤
 *          1.打开文件
 *              fs.openSync(paht,flags[,mode])
*                   - path 要打开文件的路径
 *                  - flags 打开文件要操作的类型
 *                      r  只读的
 *                      w  可写的
 *                  - mode 设置文件的操作权限，一般不传
 *                  返回值：
 *                      - 该方法会返回一个文件的描述操作符作为结果，我们可以通过
 *                         该描述符来对文件进行各种操作
 *             2.向文件中写入内容
 *                  fs.writeSync(fd, string[, position[, encoding]])
 *                      - fd 文件的描述符，需要传递要写入文件的描述符
 *                      - string 要写入的内容
 *                      - position 写入的起始位置
 *                      - encoding 写入的编码，默认utf-8
 *             3.保存并关闭文件
 *                  fs.closeSync(fd);
 *                      - fd 要关闭文件的描述符
 *
 *
* */

// 打开当前目录的文件
var fs = require("fs");
//打开文件
var fd = fs.openSync("hello.txt","w");
console.log(fd);
//想文件写入内容
fs.writeSync(fd,"今天天气真不错");
//关闭文件
fs.closeSync(fd);

三、异步文件的写入

/**
 *  异步文件写入
 *  fs.open(path,flags[,mode],callback)
 *      - 用来打开一个文件
 *      - 异步调用的方法，结构都是通过回调函数的参数返回的
 *      - 回调函数两个参数
 *          err 错误对象，如果没有错误则为null
 *          fd 文件描述符
 *       { '0': null, '1': 3 }
 *
 * fs.write(fd,string[,position[,encoding]],callback)
 *      -用来异步写入一个文件
 *
 *  fs.close(fd,callback)
 *      - 用来关闭文件
 *
* */

//引入fs模块
var fs = require("fs");

//打开文件
fs.open("fsSync.txt","w",function (err,fd) {
    // console.log(arguments);
    //判断是否出错
    if(!err){
        // console.log(fd);
        fs.write(fd,"这是异步写入的内容",function (err) {
            if(!err){
                console.log("写入成功");
            }
           fs.close(fd,function (err) {
                if(!err){
                    console.log("文件已关闭");
                }
           })
        });
    }else {
        console.log(err);
    }

})

四、简单文件写入

/**
 *  简单文件写入
 *  fs.writeFile(file,data[,options],callback)
 *  fs.writeFileSync(file,data[,options])
 *      - file 要操作文件的路径
 *      - data 要写入的数据
 *      - options 选项，可以对写入进行一些设置
 *      - callback 当写入完成后执行的函数
 *
 *      - flag
 *          r 只读
 *          w 可写
 *          a 追加
 * */

//引入fs模块
var fs = require("fs");

fs.writeFile("hello3.txt","这是通过writeFile写入的内容",{flag:"w"},function (err) {
     if(!err){
         console.log("写入成功")
     }else {
         console.log(err);
     }
});

// fs.writeFile("C:\\Users\\Mengniu\\Desktop\\hello3.txt","这是通过writeFile写入的内容",{flag:"w"},function (err) {
//     if(!err){
//         console.log("写入成功")
//     }else {
//         console.log(err);
//     }
// });

五、流式文件写入

/**
 *  同步、异步、简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出
 *
 */
var fs = require("fs");

//流式文件写入
//创建一个可写流
/**
*  fs.createWriteStream(path[,options])
 *     - 可以用来创建一个可写流
 *     - path 文件路径
 *     - options 配置的参数
 */
var ws = fs.createWriteStream("hello3.txt");

/**
 *  on（事件字符串，回调函数）
 *      - 可以为对象绑定一个事件
 *
 *  once (事件字符串，回调函数)
 *      - 可以为对象绑定一个一次性的事件，该事件将会在触发一次以后自动失效
 */

//可以通过监听流的open和close事件来监听流的打开和关闭
ws.once("open",function () {
    console.log("流打开了");
})

ws.once("close",function () {
    console.log("流关闭了");
})
//通过ws向文件中输出内容
ws.write("通过可写流写入文件内容");
ws.write("通过可写流写入文件内容");
ws.write("通过可写流写入文件内容");
ws.write("通过可写流写入文件内容");
//关闭流
ws.end();

六、文件读取

/**
 *  1.简单文件读取
 *  2.异步文件读取
 *  3.简单文件读取
 *      fs.readFile(path[,options],callback)
 *      fs.readFileSync(path[,options])
 *          - path 要读取文件的路径
 *          - options 读取的选项
 *          - callback 回调函数，通过回调函数将读取的内容返回
 *
 *  4.流士文件读取
 **/
var fs = require("fs");
fs.readFile("hello3.txt",function (err,data) {
    if(!err){
        console.log(data.toString())
    }
})

七、流式文件读取

/**
 *  流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
 *
 **/

var fs = require("fs");

//创建一个可读流
var rs = fs.createReadStream("hello3.txt");
//创建一个可写流
var ws = fs.createWriteStream("a.txt");


//监听流的开启和关闭
rs.once("open",function () {
    console.log("可读流打开");
});

rs.once("close",function () {
    console.log("可读流关闭");
    ws.end();
});
ws.once("open",function () {
    console.log("可以写流打开");
});

ws.once("close",function () {
    console.log("可写流关闭");
})



//如果要读取一个可读流的数据，必须要为可读流绑定一个data事件，data事件绑定完毕，他会自动开始读取数据
re.on("data",function (data) {
        console.log(data);
        //将读取到的数据写入到可写流中
        ws.write(data);
});

八、流式文件读取2

/**
 *  流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
 *
 **/

var fs = require("fs");

//创建一个可读流
var rs = fs.createReadStream("hello3.txt");
//创建一个可写流
var ws = fs.createWriteStream("a.txt");

//pipe() 可以将可读流中的内容，直接输出到可写流
rs.pipe(ws);

九、fs中的其他操作

/**
 *  fs.existsSync(path)
 *   - 检查一个文件是否存在
 * */

var fs = require("fs");
var isExists = fs.existsSync("hello.txt");
console.log(isExists);

/**
 *   fs.stat(path,callback);
 *   fs.statSync(path)
 *   - 获取文件的状态
 *   - 他会给我们返回一个对象，这个对象中保存了当前对象状态的信息
 * */

// fs.stat("hello3.txt",function (err,stat) {
//     /**
//      *   size 文件的大小
//      *   isFile() 是否是一个文件
//      *   isDirectory()是否是一个文件夹（目录）
//      * */
//     console.log(stat);
// });

/**
 *  fs.unlink(path,callback)
 *  fs.unlinkSync(path)
 *      - 删除文件
 * */
 // fs.unlinkSync("hello3.txt");


/**
 *  fs.readdir(path[,options],callback)
 *  fs.readdirSync(path[,options])
 *      -读取一个目录的目录结构
 *          files是一个字符串数组，每一个元素就是一个文件夹或文件名字
 *
 * */
//读取当前目录
fs.readdir(".",function (err,files) {
        if(!err){
            console.log(files);
        }
})

/**
 *  fs.truncate(path,len,callback)
 *  fs.trucateSync(path,len)
 *      - 截断文件，将文件修改为指定大小
 * */
fs.truncateSync("hello2.txt",3);


/**
 *  fs.mkdir(path[,mode],callback)
 *  fs.mkdirSync(path[,mode])
 *      - 创建一个目录
 *
 *  fs.rmdir(path,callback)
 *  fs.rmdirSync(path)
 *      - 删除一个目录
 * */
fs.mkdir("hello");
fs.rmdir("hello");

/**
 * – fs.rename(oldPath, newPath, callback)
    – fs.renameSync(oldPath, newPath)
        -重命名文件
        - 参数
            oldPath 旧的路径
            newPath 新的路径
            callback 回调函数
 * */
fs.rename("a.txt","b.txt",function () {
    if(!err) {
        console.log("修改成功");
    }
})

/**
 *  fs.watchFile(filename[,options],listener)
 *      -监视文件的修改
 *      - 参数
 *          filename 要监视的文件的名字
 *          options 配置选项
 *          listener 回调函数，当文件发生变化时，回调函数会执行
 *              在回调函数中会有两个参数
 *                  curr当前文件的状态
 *                  prev 修改当前文件的状态
 *                      - 这两个对象都是stats对象
 * */
fs.watchFile("hello2.txt",{interval:1000},function (curr,prev) {
    console.log("文件发生变化");
    console.log("修改前文件大小" + prev.size);
    console.log("修改后文件大小" + curr.size);
})

入门学习这些笔记，等实际应用者一边用一边学，在做更新