node 文件操作 读取,写入 目录的写入读取 文件流 写入流 管道流 压缩 解压

一, 文件操作

1、读取文件

引用fs模块

let fs = require(‘fs‘);

异步的方式读取文件

fs.readFile(path,fd,buffer,offset.length,position,callback)

fd:通过fs.open() 方法返回文件的描述

path:读取的文件路径

buffer：数据写入缓冲区

offset：缓冲区写入的偏移量

length:从文件中读取的字节数

position：文件读取的起始位置，如果position值为null,会从当前文件的指针位置开始读取

callback:回调函数，有两个参数，一个是错误的函数err,是第一位参数，一个是正确的函数doc，是第二位参数

// 引入文档模块
let fs = require(‘fs‘);
// 开始读文件
fs.readFile(‘./txt.txt‘,function(err,doc){
    // err的值为null说明读取成功
    if(err != null){
        console.log(err);
        return;
    }
    console.log(doc);
})

2、文件写入内容

语法：

fs.writeFile(path,file,data,callback)

参数说明：

path:文件路径

file:文件描述（文件名和文件）

data:需要写入的数据，可以直接写入，也可以引用一个变量

callback:会调函数，只有一个参数，错误参数err

fs.writeFile(‘./txt.txt‘,‘写入文件的内容‘,function(err){
	// 如果是错误，打印error
    if(err !=null){
        console.log(err);
        return;
    }
    console.log(‘文件写入成功‘);
})

二, path

不同的操作系统路径方式不一样

• /public/uploads/ataare
• window 上是: \ /
• Linux上是：/

路径拼接方法

path.join(‘路径‘，‘路径‘,........)

// 引入path模块
const path = require(‘path‘)

let filePath = path.join(‘a‘,‘b‘,‘c‘,‘d.css‘); // ./a/b/c/d.css
console.log(filePath);

相对路径和绝对路径

大多数情况下使用绝对路径，因为相对路径有时候相对的是命令行工具当前的工作目录

在读取文件或者设置问津路径的时候都会选择绝对路径

使用__dirname获取当前文件所在的绝对路径

fs.readFile(path.join(__dirname,‘txt.txt‘),(err,doc)=>{
    console.log(err);
    console.log(‘读取成功‘);
})

3、打开文件

语法

fs.open(path,flags,mode,callback)

path:打开文件的路径

flags：打开文件的行为（方式）

mode：设置文件的模式（权限）默认值是O6666(可以读，可以写)

callback：回调函数，有两个参数，一个是err,fd(描述符)

打开文件的行为

r:已读取的模式打开文件，如果文件不存在，抛出异常

r+:已读写的模式打开文件，如果文件不存在，抛出异常

rs:以同步的方式读取文件（偶尔会用）

rs+:以同步的方式读写文件（偶尔会用）

w:以写入的模式打开文件，如果文件不存在，会创建

wx:类似 w ,如果文件路径存在，文件写入会失败

w+:以读写的模式打开文件，如果文件不存在，会创建

wx+:如果文件路径在，文件写入失败

a:以追加的模式打开文件，如果文件不存在，会创建

ax:如果文件路径存在，文件会追加失败

a+:以读取追加模式打开文件，如果文件不存在，会创建

ax+:如果文件路径存在，文件会读取追加失败

fs.open(‘./txt.txt‘, ‘w‘, function (err, fd) {

    if (err) {
        return console.error(err);
        // console.log(err);
    }
    // console.log(‘打开成功‘);
    // console.log(fd);

    var writeBuffer = Buffer.from(‘我是要写入的内容11111111‘);

    fs.writeFile(fd, writeBuffer, function (err, doc) {
        if (err != null) {
            console.log(err);
            return
        }
    })

})

4、获取文件的信息

语法：

fs.stat(path,callback)

path:路径

callback:回调函数，有两个参数，比如（err,stats）,stats是fs.Stats的对象

fs.Stats（path）执行后，会将stats类的实列返回给回调函数，可以通过stats类中提供的方法，判断文件的相关属性，比如：判断是不是文件，是不是目录，是不是链接

fs.stat(‘txt.txt‘, function (err, stats) { // fs.Stats

    console.log(stats.isFile()); // 是否是文件 
})

stats.isFile():如果是文件，返回true,否则返回的是false

stats.isDirectory():如果是目录返回true,否则返回的是false

stats.isBlockDevice():如果是块设备，返回true,否则返回的是false

stats.isSymbolicLink():如果是软链接，返回true,否则返回的是false

 fs.stat(‘txt.txt‘,function(err,stats){
     if(err){
         console.log(err);
         return;
     }
     console.log(stats);
     console.log("是不是文件？" + stats.isFile());
     console.log(‘是否是目录?‘ + stats.isDirectory());
 })

5、修改文件

语法：

fs.rename(oldpath,newpath,callback)

oldpath:原来的文件的路径（被修改）

newpath：新文件的路径（修改）

callback:回调函数，没有参数

 fs.rename(‘a.txt‘,‘txt.txt‘,function(err){
     if(err){
        throw err;
     }
     console.log(‘修改成功‘);
 })

6、删除文件

语法

fs.unlink(path,callback)

path:路径

callback:回调函数，没有参数

fs.unlink(‘./txt.txt‘,function(err){
    if(err){
        throw err
    }
    console.log(‘删除成功‘);
})

完整版

var fs = require(‘fs‘);
fs.open(‘./txt.txt‘, ‘a+‘, function (err, fd) {
    // 打开文件后，创建缓冲区放置数据
    var readBuf = Buffer.alloc(1024), // 读取多少字节
        bufOffset = 0,
        readbufLength = readBuf.length, //长度
        filePosition = 50; // 从第50个字节开始

    // 读文件
    fs.read(fd, readBuf, bufOffset, readbufLength, filePosition, function (err, readBytes, buffer) {
        console.log(‘err:‘ + err);
        console.log(‘readBytes:‘ + readBytes);
        console.log(‘buffer:‘ + buffer);
    })

    // 写入文件
    var writeBuf = Buffer.from(‘我是要写入的内容‘),
        bufPosition = 0, // 等待写入数据在缓冲区的位置
        writbufLength = writeBuf.length, // 写入的数据的长度
        filePosition = null; // 从文件的什么位置开始写入数据

    fs.write(fd, writeBuf, bufPosition,writbufLength,filePosition, function (err, bytesWritten, buffer) {
        console.log(err);
        console.log(bytesWritten);
        console.log(buffer.toString());
    })

    // 关闭文件
    fs.close(fd, function () {
        console.log(‘读取完毕，关闭文件‘);
    })
})

7、创建目录

语法：

fs.mkdir(path,callback)

path:文件路径

callback:回调函数 没有参数

const { log } = require(‘console‘);
var fs = require(‘fs‘);
// 这种方式的创建，必须有上一级的目录，也就是test这个文件夹必须存在的
fs.mkdir(‘test/test1‘,function(err){
    if(err){
        console.log(err);
        return;
    }
    console.log(‘创建成功‘);
})

// 上一级目录可以不存在
// recursive:true：默认值是false,如果为true,可以没有上一级目录，也可以自动创建
fs.mkdir(‘test/a/apple‘,{recursive:true}, (err) =>{
    if(err){
        console.log(err);
        return;
    }
    console.log(‘创建成功‘);
})

8、读取目录

语法：

fs.readdir(path,callback)

path:文件路径

callback:回调函数，有两个参数，一个是错误的函数err,一个是files,是目录下文件的数组列表

fs.readdir(‘test/a/‘, function (err, files) {

if(err){
    console.log(err);
    return
}
console.log(‘读取成功‘);
// console.log(files);

files.forEach(function(file){ // 数组里面的每一个元素
    console.log(file);
})

})

9、删除目录

语法

fs.rmdir(path,callback)

path:文件路径

callback:回调函数，没有参数

fs.rmdir(‘./test‘,function(err){
    if(err){
        console.log(err);
        return;
    }
    console.log(‘删除成功‘);
})

三, 文件流

Stream是一个抽象的接口，有个stdout标准输出

四种流类型：

Readable:可以读的操作

Writeable:可以写的操作

Duplex:可以读可以写的操作

Transform:操作被写入的数据，然后读出结果

四种事件

data:当有数据可以读的时候触发

end:没有更多的数据可读的时候触发

error:在接收或者写入的过程当中发生错误的时候触发

finish:所有数据已经被写入到底层系统的时候触发

open：打开文件的时候触发的事件

读取数据

var fs = require(‘fs‘); // 
var data = ‘‘; //  我是被读取的数据内容

// 创建一个可以读的流
var readerStream = fs.createReadStream(‘1txt.txt‘);
// 设置字符编码
readerStream.setEncoding(‘utf-8‘);

// 处理流事件  data  - end  error

readerStream.on(‘data‘,function(a){
    data +=a;
})

readerStream.on(‘end‘,function(){
    console.log(data); /// 打印数据
})

readerStream.on(‘error‘,function(err){
    console.log(err);
})

console.log(‘读取成功‘);

11、写入流

var fs = require(‘fs‘);
var data = ‘万维网.www.baidu.com‘;
// 创建一个可以写入的流 写入到文件中
var creatWriteStream = fs.createWriteStream(‘pt.txt‘);

// 设置编码 使用utf-8方式写入数据
creatWriteStream.write(data,‘utf-8‘);

// 处理流事件  finish  error
creatWriteStream.on(‘finish‘,function(){
    console.log(‘写入完成‘);
})
creatWriteStream.on(‘error‘,function(err){
    if(err){
        console.log(err);
        return;
    }
})

12、管道流

var fs = require(‘fs‘); 

// 创建一个可以读的流
var createReadStream = fs.createReadStream(‘txt.txt‘)
// 创建一个可以写的流
var creatWriteStream = fs.createWriteStream(‘pt.txt‘);
// 管道操作
createReadStream.pipe(creatWriteStream);

四, 链式流 压缩 解压

一个是用来生成压缩文件

// 引入文件莫快
var fs = require(‘fs‘);
// 引入压缩的模块
var zLib = require(‘zlib‘);  

// 压缩pt.txt文件为pt.txt.rar .gz
fs.createReadStream(‘pt.txt‘).pipe(zLib.createGzip()).pipe(fs.createWriteStream(‘pt.txt.gz‘));
console.log(‘压缩完成‘);

一个是用来解压文件

var fs = require(‘fs‘);
var zLib = require(‘zlib‘);  
fs.createReadStream(‘txt.txt.rar‘).pipe(zLib.createGzip()).pipe(fs.createWriteStream(‘txt.txt‘));
console.log(‘解压完成‘)

node 文件操作 读取,写入 目录的写入读取 文件流 写入流 管道流 压缩 解压

原文：https://www.cnblogs.com/bnzw/p/13905151.html