Node.js fs文件系统模块

fs模块文件系统
异步方法性能更高，速度更快，而且没有阻塞
文件读取写到服务端上
加载文件系统模块 var fs = require("fs");

判断是 文件/目录 stat

fs.stat(path, callback(err, stats))

stats 是 fs.Stats 对象

        fs.stat('./comment', (err, stats) => {
            if (err) {throw err;}
            console.log("是文件:" + stats.isFile());
            console.log("是目录:" + stats.isDirectory());
        });

读取目录里的文件 readdir

fs.readdir(path, callback(err,files)=>{})

files 为 目录下的文件数组列表
path 文件路径 "./path/"

//检测一个目录里面的所有的文件是目录还是文件   递归检测
        let unload = "comment";
        readFile(unload);
        function readFile(url) {
            fs.readdir(url, (err, files) => {
                if (err) {
                    throw err;
                }
                //对返回的所有的文件进行便利
                for (let index in files) {
                    //判断当前的文件
                    fs.stat(url + "/" + files[index], (error, stats) => {
                        if (error) {
                            throw error;
                        }
                        console.log(files[index] + "是" + (stats.isFile() ? '文件' : '目录'));
                        if (stats.isDirectory()) {
                            unload = url;//还原回当前目录的顶级目录
                            unload += "/" + files[index];
                            readFile(unload);
                        }
                    });
                }
            });
        }

创建mkdir/移除rmdir 目录

如果目录已经存在不在创建 一般用于图片的上传与下载上
fs.mkdir(path[, options], callback)
fs.rmdir(path, callback)

options 参数:
recursive - 是否以递归的方式创建目录，默认为 false。
mode - 设置目录权限，默认为 0777。

打开关闭文件 open close
fs.open(path, flags[, mode], callback(err,fd)) fs.close(fd, callback)

	path - 文件的路径。
	flags - 文件打开的行为。
	mode - 设置文件模式(权限)，文件创建默认权限为 0666(可读，可写)。
	callback(err,fd) - 回调函数，err, fd：文件描述符。

fs.open('./comment/router', 'r+', (err, fd) => {
            if (err) {
                throw err;
            }
            console.log("文件以打开");
            console.log("这里在操作");

            //关闭文件
            fs.close(fd, (err) => {
                if (err) {
                    console.log("关闭失败");
                    return;
                }
                console.log("关闭成功！");
            });

        });

读取文件 read

先打开文件返回fd，建立缓冲区 let buf =new Buffer(length)
fs.read(fd, buffer, offset, length, position, callback(err, bytesRead, buffer))

fd - 通过 fs.open() 方法返回的文件描述符。
buffer - 数据写入的缓冲区。
offset - 缓冲区写入的写入偏移量。
length - 要从文件中读取的字节数。
position - 文件读取的起始位置，如果 position 的值为 null，则会从当前文件指针的位置读取。
callback(err, bytesRead, buffer) - 回调函数，err 为错误信息， bytesRead 表示读取的字节数，buffer 为缓冲区对象。	

var buf = new Buffer.alloc(1024);
 fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }
      console.log(bytes + "  字节被读取");
      
      // 仅输出读取的字节
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }
   });

读取文件内容readFile

fs.readFile(path,option,callback)

//异步读取
fs.readFile('input.txt','utf-8', function (err, data) {
   if (err) {
       return console.error(err);
   }
   console.log("异步读取: " + data.toString());
   //data 返回的数据格式是buffer格式
   //buffer 转化字符串   toString() 
});
//同步读取
data = fs.readFileSync('input.txt');
console.log("同步读取: " + data.toString());

写入文件 内容覆盖 writeFile

fs.writeFile(file, data[, options], callback)

file - 文件名或文件描述符。

data - 要写入文件的数据，可以是 String(字符串) 或 Buffer(缓冲) 对象

options - 该参数是一个对象{encoding:'utf-8', mode:'0666', flag;'w'}。默认编码为 utf8, 模式为 0666 ， flag 为 'w'

fs.writeFile(mulu+'/'+'user.txt','data数据内容',(errinfo)=>{
                    if(errinfo){
                        console.log("写入失败！");
                        return;
                    }
                    console.log("写入成功！");
                });

追加写入文件 appendFile

fs.appendFile(file,data,callback)

 fs.appendFile(mulu + '/' + 'user.txt', '我在追加写入-测试\n', (errinfo) => {
                    if (errinfo) {
                        console.log("写入失败！");
                        return;
                    }
                    console.log("写入成功！");

单文件删除 unlink rmdir

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

        fs.unlink('./page/stu.txt', (err) => {
            if (err) {
                console.log("删除失败！");
                return;
            }
            console.log("删除成功！");
        });

flags 参数

r	r+	rs	rs+
读取模式 文件不存在抛出异常	读写模式文件 文件不存在抛出异常	同步读取	同步读写
w	w+	wx	wx+
写入模式 文件不存在则创建	读写模式 文件不存在则创建	写入模式 文件路径存在，则文件读写失败	读写模式 文件路径存在，则文件读写失败
a	a+	ax	ax+
追加模式打开 文件不存在则创建	读取追加模式打开文件 文件不存在则创建	类’a’ 文件路径存在，则文件追加失败	类似 'a+' 文件路径存在，则文件读取追加失败

文件流

let data=""; 接收读取的数据

读取流 readStream

创建读取流
let readStream=fs.createReadStream('public/jq.txt',{flags:'r+',encoding:'utf-8',start:0,end:1024});
流的监听事件 end error data

readStream.on('data',(res)=>{
    //当有数据可读的时候触发
    data+=res;
});
readStream.on('end',()=>{
    //当没有数据可读的时候
    //console.log(data);
    //创建写入
    let writeStream=fs.createWriteStream('public/data.txt',{flags:'r+',encoding:'utf-8'});
    writeStream.write(data);
});
readStream.on('error',(err)=>{
    //读取或者写入的时候触发事件
    console.log(err);
});

写入流 writeStream

//创建写入流
let writeStream=fs.createWriteStream('public/data.txt');
//设置写入的数据和编码
writeStream.write('写入流','utf-8');
//写入完成
writeStream.end();
writeStream.on('finish',()=>{
    console.log('写入完成');
});

管道流 边读边写

//创建 读入流、写入流
let readStream=fs.createReadStream('public/jq.txt');
let writeStream=fs.createWriteStream('public/data.txt');
//管道
readStream.pipe(writeStream);

链式流 应用于管道流

let zib=require('zlib');//文件压缩
fs.createReadStream('public/jq.txt')
.pipe(zib.createGzip())
.pipe(fs.createWriteStream('public/jq.zip'));