Node.js Buffer、fs同步和异步（写入，读取）简单（写入、读取）流式（写入、读取)

最新推荐文章于 2025-05-17 19:53:12 发布

原创最新推荐文章于 2025-05-17 19:53:12 发布 · 3.9k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#nodejs

node.js 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了Node.js中的Buffer类，用于处理二进制数据，详细阐述了Buffer的创建、字符编码以及常用方法。同时，文章详细探讨了fs模块的同步和异步文件读写操作，包括简单的文件写入、流式文件写入和读取，强调了同步和异步的区别以及在使用过程中的注意事项。

Buffer缓冲区

JavaScript 语言自身只有字符串数据类型，没有二进制数据类型，所以Buffer就是用来存储二进制文件的。

但在处理像TCP流或文件流时，必须使用到二进制数据。因此在 Node.js中，定义了一个 Buffer 类，该类用来创建一个专门存放二进制数据的缓存区。一个 Buffer 类似于一个整数数组，但它对应于 V8 堆内存之外的一块原始内存。

在v6.0之前创建Buffer对象直接使用new Buffer()构造函数来创建对象实例，但是Buffer对内存的权限操作相比很大，可以直接捕获一些敏感信息，所以在v6.0以后，官方文档里面建议使用 Buffer.from() 接口去创建Buffer对象

Buffer 与字符编码

Buffer 实例一般用于表示编码字符的序列，比如 UTF-8 、 UCS2 、 Base64 、或十六进制编码的数据。通过使用显式的字符编码，就可以在 Buffer 实例与普通的 JavaScript 字符串之间进行相互转换。

在缓冲区和字符串之间进行转换时，可以指定字符编码。如果没有指定字符编码，将使用UTF-8作为默认值。

const buf = Buffer.from('runoob', 'ascii');

// 输出 72756e6f6f62
console.log(buf.toString('hex'));

// 输出 cnVub29i
console.log(buf.toString('base64'));

Node.js 目前支持的字符编码包括：

ascii - 仅支持 7 位 ASCII 数据。如果设置去掉高位的话，这种编码是非常快的。
utf8 - 多字节编码的 Unicode 字符。许多网页和其他文档格式都使用 UTF-8 。
utf16le - 2 或 4 个字节，小字节序编码的 Unicode 字符。支持代理对（U+10000 至 U+10FFFF）。
ucs2 - utf16le 的别名。
base64 - Base64 编码。
latin1 - 一种把 Buffer 编码成一字节编码的字符串的方式。
binary - latin1 的别名。
hex - 将每个字节编码为两个十六进制字符。

Buffer 使用

直接使用不需要引入模块，直接使用即可。

Buffer 类是一个全局变量，用于直接处理二进制数据。它可以使用多种方式构建。

Buffer.from(array)#

新增于: v5.10.0

array <integer[]>

使用 0 – 255 范围内的字节数组 array 来分配一个新的 Buffer。超出该范围的数组条目会被截断以适合它。

// 创建一个包含字符串 'buffer' 的 UTF-8 字节的新 Buffer。
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);

如果 array 不是一个 Array 或适用于 Buffer.from() 变量的其他类型，则抛出 TypeError。

Buffer.from(array) 和 Buffer.from(string) 也可以像 Buffer.allocUnsafe() 一样使用内部的 Buffer 池。

Buffer.alloc(size[, fill[, encoding]])

size <integer> 新 Buffer 的所需长度。
fill <string> | <Buffer> | <Uint8Array> | <integer> 用于预填充新 Buffer 的值。默认值: 0。
encoding <string> 如果 fill 是一个字符串，则这是它的字符编码。默认值: 'utf8'。

const b = Buffer.alloc(10,"李连杰","utf8");
console.log(b.toString());

Buffer.allocUnsafe(size)

size <integer> 新建的 Buffer 的长度。

创建一个大小为 size 字节的新 Buffer。如果 size 大于 buffer.constants.MAX_LENGTH 或小于 0，则抛出 ERR_INVALID_OPT_VALUE。

以这种方式创建的 Buffer 实例的底层内存是未初始化的。新创建的 Buffer 的内容是未知的，可能包含敏感数据。使用 Buffer.alloc() 可以创建以零初始化的 Buffer 实例。

const buf = Buffer.allocUnsafe(10);
console.log(buf);
// 打印（内容可能有所不同）: <Buffer a0 8b 28 3f 01 00 00 00 50 32>
buf.fill(0);
console.log(buf);
// 打印: <Buffer 00 00 00 00 00 00 00 00 00 00>

对比Buffer.alloc(size[, fill[, encoding]])和Buffer.allocUnsafe(size)

alloc：安全，效率低

allocUnsafe：不安全，效率高，会泄露敏感信息。

fs的同步和异步调用：

fs模块中所有的操作都有两种形式可以选择，同步和异步。
同步晚间系统会阻塞程序的运行，也就是除非操作完毕，否则不会向下执行代码。
异步文件系统不会阻塞程序的执行，二是在操作完成时，通过回调函数将结果返回。

fs写入文件

同步文件写入

1.打开文件

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

path <string> | <Buffer> | <URL>
flags <string> | <number> 默认值: 'r'，说明对文件的操作方式比如说

'r'就是只读

'w'就是可写。

mode <string> | <integer> 默认值: 0o666。

设置文件的操作权限，一般用于Linux。

返回: <number>返回表示文件描述符的整数。
返回一个描述符，相当于标志，实际值没有意义，就相当于给你打开的文件起个别名，以后你就可以将其作为这个文件的标志。

2.写入文件

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

fd <integer> 文件描述符，需要传递要写入文件的文件描述符

string <string> 要写入的内容
position <integer>写入起始位置
encoding <string>编码默认utf8
返回: <number> 写入的字节数。

3.关闭文件

fs.closeSync(fd)

fd <integer>

同步的 close(2)。返回 undefined。

通过任何其他 fs 操作在当前正在使用的任何文件描述符（fd）上调用 fs.closeSync() 可能导致未定义的行为。

fs同步写入文件

//引入fs模块
const  fs = require("fs");
//打开一个文件
var file = fs.openSync("./hello.txt",'w');
console.log("文件描述符："+file);
fs.writeSync(file,"今天很高兴学习fs文件写入!");
fs.closeSync(file);

fs异步写入文件

1.打开文件

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

中英对照提交修改

path <string> | <Buffer> | <URL>

flags <string> | <number> 参见文件系统 flag 的支持。 默认值: 'r'。
mode <string> | <integer> 默认值: 0o666（可读写）。
callback <Function>
- err <Error>错误对象，没有错误则为null，错误优先
- fd <integer>文件描述符

mode 用于设置文件模式（权限和粘滞位），但仅限于创建文件时。在 Windows 上，只能操作写权限，参见 fs.chmod()。

回调有两个参数 (err, fd)。

有些字符 (< > : " / \ | ? *) 在 Windows 上是预留的，参见命名文件、路径以及命名空间。在 NTFS 上，如果文件名包含冒号，则 Node.js 会打开文件系统流，参见此 MSDN 页面。

基于 fs.open() 的函数也会表现出以上行为，比如 fs.writeFile()、 fs.readFile() 等。

//引入fs模块
const  fs = require("fs");
//打开一个文件
fs.open("./hello2.txt","w",function (error,fd) {
    console.log("文件描述符："+fd);
    if(error){
       console.log(error);
    }else{
       fs.writeSync(fd,"今天很高兴学习fs文件写入!");
    }
       fs.closeSync(fd);

})

简单文件写入

异步

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

file <string> | <Buffer> | <URL> | <integer> 文件名或文件描述符。
data <string> | <Buffer> | <TypedArray> | <DataView>
options <Object> | <string>
- encoding <string> | <null> 默认值: 'utf8'。
- mode <integer> 默认值: 0o666。
- flag <string> 参见文件系统 flag 的支持。 默认值: 'w'。
callback <Function>
- err <Error>

当 file 是文件名时，则异步地写入数据到文件（如果文件已存在，则覆盖文件）。 data 可以是字符串或 buffer。

当 file 是文件描述符时，则其行为类似于直接调用 fs.write()（建议使用）。参见以下关于使用文件描述符的说明。

如果 data 是 buffer，则 encoding 选项会被忽略。

const data = new Uint8Array(Buffer.from('Node.js 中文网'));
fs.writeFile('文件.txt', data, (err) => {
  if (err) throw err;
  console.log('文件已被保存');
});

//引入fs模块
const  fs = require("fs");
//写入一个文件
fs.writeFile("hello3.txt","这是通过writeFile写入的内容",function (error) {
    if(!error){
        console.log("写入成功：");
     }
})

同步

`fs.writeFileSync(file, data[, options])`

file <string> | <Buffer> | <URL> | <integer> 文件名或文件描述符。
data <string> | <Buffer> | <TypedArray> | <DataView> 要写入的数据
options <Object> | <string>
- encoding <string> | <null> 默认值: 'utf8'。
- mode <integer> 默认值: 0o666。
- flag <string> 参见文件系统 flag 的支持。 默认值: 'w'。

返回 undefined。

//引入fs模块
const  fs = require("fs");
//打开文件
fs.open('hello4.txt', 'a', function(err,fd){
    if(err){
        throw err;
    }
    var data = '同步简单写入';
    var buf = new Buffer(8);
    fs.writeSync(fd, buf, 0, 8, 0);
    fs.close(fd,function(err){
        if(err){
            throw err;
        }
        console.log('file closed');
    })
})

流式文件写入

1创建一个可写流

fs.createWriteStream(path[, options])

path <string> | <Buffer> | <URL> 文件路径
options <string> | <Object> 配置的参数
- flags <string> 参见文件系统 flag 的支持。 默认值: 'w'。
- encoding <string> 默认值: 'utf8'。
- fd <integer> 默认值: null。
- mode <integer> 默认值: 0o666。
- autoClose <boolean> 默认值: true。
- emitClose <boolean> 默认值: false。
- start <integer>
- fs <Object> | <null> 默认值: null。
返回: <fs.WriteStream>

2通过可写流写入内容

//流式文件写入
const fs  =  require("fs");
//创建可写流
const  fw = fs.createWriteStream("hello.txt");
//通过可写流写入内容
fw.write("通过可写流写入文件的内容0");
fw.write("通过可写流写入文件的内容1");
fw.write("通过可写流写入文件的内容2");
fw.once("open",function () {
    console.log("流打开了~~~");
})
//关闭输出方的流
fw.end();

注意：流式写入关闭的时候要关闭输入方的流，不能关闭接受方的流，因为写入方只需将内容传送到流（水管）中就可以关闭了，但是如果接受方关闭流的话，就相当于主动拔掉水管不接受水管中的内容。

fs读取文件

同步

`fs.readFileSync(path[, options])`

path <string> | <Buffer> | <URL> | <integer> 文件名或文件描述符。
options <Object> | <string>
- encoding <string> | <null> 默认值: null。
- flag <string> 参见文件系统 flag 的支持。 默认值: 'r'。
返回: <string> | <Buffer>

返回 path 的内容。

异步：

`fs.readFile(path[, options], callback)`#

path <string> | <Buffer> | <URL> | <integer> 文件名或文件描述符。
options <Object> | <string>
- encoding <string> | <null> 默认值: null。
- flag <string> 参见文件系统 flag 的支持。默认值: 'r'。
callback <Function>
- err <Error>
- data <string> | <Buffer>

异步地读取文件的全部内容。

同步和异步如下：

var  fs = require('fs');
//导入文件模块
//node 同步读文件
var  sycContext  = fs.readFileSync("hello.txt",{flag:'r',encoding:"UTF-8"});
console.log(content.toString());
//node 异步读文件，
var  content = fs.readFile("hello.txt",{flag:'r',encoding:"UTF-8"},function (err,data) {
    if(err){
        console.log(err);
    }else{
        console.log(data);
    }
});

简单文件读取

const fs  =  require("fs");
const path = "zz.jpg";
const content = fs.readFile(path,{flag:'r'},function (err,data) {
    if(err){
        console.log(err);
    }else{
        fs.writeFile("dog.jpg",data,function () {
            console.log(data);
        })
    }
});

流式文件读取

如果要读取一个可读流中的数据，必须腰围可读流绑定一个事件，data事件绑定完毕，它会自动开始读取数据。

const fs  =  require("fs");
const fr = fs.createReadStream("hello.txt");
fr.once("open",function () {
    console.log("流打开了");
})

fr.on("data",function (data) {
    console.log(data,data.length);
})

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

文件操作状态

模式	说明
r	读取文件，文件不存在则出现异常
r+	读写文件，文件不存在则出现异常
rs	在同步模式下打开文件用于读取
rs+	在同步模式下打开文件用于读取
w	打开文件用于写操作，如果不存在则创建，如果存在则截断（干掉）
wx	打开文件用于写操作，如果存在则打开失败
w+	打开文件用于读写，如果不存在则创建，如果存在则截断（干掉）
wx+	打开文件用于读写，如果存在则打开失败
a	打开文件用于追加，如果不存在则创建
ax	打开文件用于追加，如果文件路径存在则失败
a+	打开文件进行读取和追加，如果不存在则创建该文件
ax+	打开文件进行读取和追加，如果路径存在则失败