个人学习记录，仅供参考

文件系统（File System）

文件系统简单来说就是通过Node来操作系统中的文件

使用文件系统，需要先引入fs模块，fs是核心模块，直接引入 不需要下载

const fs = require('fs');

文件写入

同步文件写入

代码逐条执行，会阻塞

操作步骤

打开文件

 fs.openSync(path, flags[, mode]);

• path 要打开文件的路径

• flags 打开文件要做的操作的类型

  • r 只读的
  • w 可写的
• mode 可选的 设置文件的操作设置权限 一般不会传

• 返回值：

  • 该方法会返回一个文件的描述符 作为结果 我们可以通过该描述符来对文件的各种操作

向文件中写入内容

fs.writeSync(fd, string[, position[, encoding]]);  

• fd 文件的描述符 ，需要传递要写入的文件的描述符
• string 要写入的内容
• position 写入的起始位置 //可选
• encoding 写入的编码，默认utf-8 //可选

保存并且关闭文件

fs.closeSync(fd);

• fd 要关闭文件的描述符

例子

//引入文件系统
const fs = require('fs');
//打开文件
var fd = fs.openSync('test.txt','w');
//向文件中写入内容
fs.writeSync(fd,'重返十七岁');
//关闭文件
fs.closeSync(fd);

异步文件写入

代码会一起执行不会阻塞

操作步骤

打开文件

fs.open(path, flags[, mode], callback);

• 异步调用的方法，结果都是通过回调函数的参数返回的

  • 回调函数有两个参数：

    • err 错误对象 如果没有错误则为 null
    • fd 文件的描述符

写入文件

fs.write(fd, string[, position[, encoding]], callback);

关闭文件

fs.close(fd, callback);

例子

//引入fs模块
const fs = require('fs');
//打开文件
fs.open('test.txt','w',function (err,fd) {
    //判断是否出错
    if(!err){
        // 写入文件
        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 选项，可以对写入进行一些设置 （可选）

  • 操作符（flag）：

    • r 只读
    • w 可写
    • a 追加
• callback 回调函数，当我们写入完成以后执行的函数

例子

const fs = require('fs');
fs.writeFile('test.txt','通过writeFile写入的内容',{flag:"a"},function (err) {
        if(!err){
            console.log("写入成功");
        }
});

流式文件写入

同步，异步，简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出，而流式文件写入会 一点一点的写入进去 不会导致内存溢出的状况

引入文件系统模块

var fs = require('fs');

创建一个可写流

 fs.createWriteStream(path[, options]);

• 可以创建一个可写流
• path 文件路径
• options 配置参数

打开文件

var ws = fs.createWriteStream('hello3.txt');

监听流 可选

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

• 可以通过监听流的open和close事件来监听流的打开和关闭

• on(事件字符串,回调函数)

  • 可以为对象绑定一个事件

• once(事件字符串,回调函数)

  • 可以为对象绑定一个一次性的事件，该事件将会在出发一次以后自动失效

通过ws向文件中输出内容

ws.write("通过可写流写入文件的内容1");
ws.write("通过可写流写入文件的内容2");
ws.write("通过可写流写入文件的内容3");
ws.write("通过可写流写入文件的内容4");
ws.write("通过可写流写入文件的内容5");

关闭流

ws.end();

文件读取

简单文件读取

 fs.readFile(path[, options], callback);
 fs.readFileSync(path[, options]);

• path 要读取文件的路径

  • options 读取的选项

  • callback 回调函数 通过回调函数将读取到的内容返回

    • err 错误对象
    • data 读取到的数据 会返回一个buffer

例子

var fs = require('fs');

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

流式文件读取

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

绑定方法

例子

var fs = require('fs');

// 创建一个可读流
var rs = fs.createReadStream('0.jpg');

//创建一个可写流
var ws = fs.createWriteStream('test.jpg')

// 监听流的开启和关闭

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.length);
    //将读取到的数据写入到可写流中
    ws.write(data);
});

pipe方法

例子 官方文档

var fs = require('fs');

// 创建一个可读流
var rs = fs.createReadStream('0.jpg');

//创建一个可写流
var ws = fs.createWriteStream('test.jpg')

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

ws.once('open',function () {
    console.log("可写流打开了");
});
ws.once('close',function () {
    console.log("可写流关闭了");
});

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

常用方法

检查一个文件是否存在

fs.existsSync(path);

例子

var isExists = fs.existsSync('test.jpg');
console.log(isExists);

获取文件状态

fs.stat(path[, options], callback)  
fs.statSync(path[, options])

• 它会返回一个对象，这个对象中保存了当前对象状态的相关信息

例子
官网

fs.stat('test.jpg',function (err,stats) {
    /**
     * size 文件的大小
     * isFile() 是否 是一个文件
     * isDirectory() 是否 是一个文件夹（目录）
     */
    if(!err){
        console.log(stats.isDirectory() );
    }
});

删除文件

fs.unlink(path, callback)
fs.unlinkSync(path)

例子

fs.unlinkSync("test.jpg");    

读取一个目录的目录结构

 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('test.txt',10);    

创建一个文件夹（目录）

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

例子

fs.mkdirSync("test");    

删除一个目录

 fs.rmdir(path, callback)
 fs.rmdirSync(path) 

例子

fs.rmdirSync("test");  

重命名文件夹

fs.rename(oldPath, newPath, callback)
fs.renameSync(oldPath, newPath)

• 参数

  • oldPath 旧的路径
  • newPath 新的路径
  • callback 回调函数

例子

fs.rename('test1.jpg','test2.jpg',function (err) {
    if (!err) {
        console.log('修改成功');
    }
});    

监视文件的修改

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

• 参数

  • filename 要监视的文件名字

  • options 配置选项

    • 官网默认5s 可调 interval

  • listener 回调函数 当文件发生变化时 回调函数会执行

    • 在回调函数中有两个参数

      • curr 当前文件的状态

      • prev 修改前文件的状态

        • 这两个对象都是 stats对象

例子
官网

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