Node基础_文件系统

文件系统（File System）

   - 文件系统简单来说就是通过Node来操作系统中的文件的
   - 使用文件系统，需要先引入fs模块，fs是核心模块，直接引入不需要下载

同步文件的写入

- 手动操作的步骤：

1.打开文件

fs.openSync(path, 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");

//向文件中写入内容
fs.writeSync(fd, "今天的天气真不错~~~", 2);

//关闭文件
fs.closeSync(fd);

异步文件写入

1.打开文件

fs.open(path, flags[, mode], callback)
       - 用来写入一个文件
       - 异步调用的方法，结果都是通过回调函数的参数返回
       - 回调函数有两个参数：
           err 错误对象，如果没有错误则为null
           rd  文件的描述符

2.向文件中写入内容

fs.writeSync(fd, string[, position[, encoding],callback])
       - 用来异步写入一个文件

3.保存并关闭文件

fs.closeSync(fd， callback)
       - 用来关闭一个文件

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

var f;

//打开文件
fs.open("hello2.txt" , "w",function (err, fd) {
   //console.log("回调函数中的代码~~~");
    //判断是否出错
    if(!err){

        //如果没有出错，则对文件进行写入操作
        fs.write(fd,"这是异步写入的内容",function (err) {
            if(!err){
                console.log("写入成功~~~");
            }

            //关闭文件
            fs.close(fd,function (err) {
                if(!err){
                    console.log("文件已关闭~~~");
                }
            })
        });



    }else {
        console.log(err);
    }
});

console.log("程序向下运行~~~");

简单文件写入

fs.writeFile(file, data [, options],callback)
fs.writeFileSync(file, data [, options])
        - file 要操作的文件路径
        - data 要写入的数据
        - options 选项，可以写入进行一些设置
        - callback 当写入完成以后执行的函数

        - flag
            r 只读
            w 可写
            a 追加

var fs = require("fs");

//flag里面 w: 打开文件用于写操作，如果不存在则创建，如果存在则截断
//         a: 打开文件用于追加，如果不存在则创建
fs.writeFile("C:\Users\孙娇娇\Desktop\hello.txt", "这是通过writeFile写入的内容",{flag:"a"},function (err) {
    if(!err){
        console.log("写入成功~~~");
    }else{
        console.log(err);
    }
});

流式文件写入

注：

同步、异步、简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出

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

可以通过监听流的open和close事件来监听流的打开和关闭
 on(事件字符串，回调函数)
    - 可以为对象绑定长期有效事件
 once/one(事件字符串，回调函数)
    - 可以为对象绑定一个一次性事件，该事件将会在触发一次以后自动失效

ws.once("open",function () {
    console.log("流打开了~~~");
});

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

//通过ws向文件中输出内容
ws.write("通过可写流写入文件的内容");
ws.write("锄禾日当午");
ws.write("苏万彬吃土");
ws.write("谁知盘中餐");
ws.write("万彬不知苦");
ws.write("(づ￣3￣)づ╭❤～)");

//关闭流
ws.end();

同步文件读取

异步文件读取

 

简单文件读取

fs.readFile(path[, options],callback)
fs.readFileSync(path[, options])
      - path 要读取的文件的路径
      - options 读取的选项
      - callback 回调函数,通过回调函数将读取到内容返回（err , data）
         err 错误对象
         data 读取到的数据，会返回一个Buffer

//简单文件读取
var fs = require("fs");

fs.readFile("a.jpeg" , function (err , data) {
    if(!err){
        //console.log(data);
        //将data写入到文件中
        fs.writeFile("hello.jpeg",data,function (err) {
            if(!err){
                console.log("写入成功~~~");
            }
        })
    }
});

流式文件读取

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

//流式文件读取
var fs = require("fs");

//创建一个可读流
var rs = fs.createReadStream("a.jpeg");

//创建一个可写流
var ws = fs.createWriteStream("hello.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事件绑定完毕，它会自动开始读取数据
rs.on("data",function (data) {
    //console.log(data);
    //将读取到的数据写入到可写流中
    ws.write(data);

});

上面流式文件读取的代码比较乱，那我们可以用另一种方式代替：

//流式文件读取
var fs = require("fs");

//创建一个可读流
var rs = fs.createReadStream("a.jpeg");

//创建一个可写流
var ws = fs.createWriteStream("hello.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("hello.txt",function (err , stat) {
        size 文件的大小
        isFile() 是否是一个文件
        isDirectory() 是否是一个文件夹
   
   console.log(stat.isDirectory());
});

 

③ fs.unlink(path, callback)

      fs.unlinkSync(path)

     - 删除文件

fs.unlinkSync("hello.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.truncateSync(path, len)

     - 截断文件

fs.truncateSync("hello4.txt",3);

⑥ fs.mkdir(path[, mode], callback)

      fs.mkdirSync(path[, mode])

          - 创建一个目录,将文件修改为指定的大小

     fs.rmdir(path, callback) 

     fs.rmdirSync(path)

          - 删除一个目录

fs.mkdirSync("hello");
fs.rmkdirSync("hello");

⑦  fs.rename(oldPath, newPath, callback)

       fs.renameSync(oldPath, newPath)

      - 对文件进行重命名
      - 参数：
        oldPath 旧的路径
        newPath 新的路径
        callback 回调函数

fs.rename("a.jpeg","hello.txt",function (err) {
    if(!err){
        console.log("修改成功~~~");
    }
});

⑧fs.watchFile(filename[, options], listener)

    - 监视文件的修改
    - 参数：
       filename 要监视的文件的名字
       options 配置选项
           - interval :间隔
       listener 回调函数，当文件发生变化时，回调函数会执行
              在回调函数中会有两个参数：
                curr 当前文件的状态
               prev 修改前文件的状态
                    - 这两个对象都是stats对象

fs.watchFile("hello.txt",{interval:1000},function (curr,prev) {
    console.log("修改前文件大小："+prev.size);
    console.log("修改后文件大小："+curr.size);
});