node buffer

最新推荐文章于 2025-08-06 10:49:34 发布
最新推荐文章于 2025-08-06 10:49:34 发布
阅读量1.2k 收藏
点赞数
分类专栏： Node.Js

缓冲器类

稳定性： 3 - 稳定

纯粹的JavaScript语言对处理Unicode非常友好，但却对二进制数据束手无策。在处理TCP流或文件系统时，不得不操作字节流。Node拥有操作、创建以及消耗字节流等的一系列策略。

原始数据储存在缓冲器类的实例中。缓冲区像是一个整型数组，只不过是在V8堆外分配的一个原始内存块。 缓冲区是不能改变大小的。

缓冲器类是全局对象，必须使用require('buffer')的情况非常少见。

在缓冲流和JavaScript字符串对象之间转换，需要显式提供编码方法。如下列举了不同的字符编码。

  • 'ascii' -仅用于7位的ASCII数据。这种编码方法非常快速，并且一旦设置便会抛弃高位数据。注意，这个编码方式会将空字符（'\0' 或 '\u0000'）转换成0x20（空格的字符编码）。如果想把空字符转换成0x00，得使用'utf8'。

  • 'utf8' -多字节编码的Unicode字符。许多网页以及其它文档格式会使用UTF-8编码。

  • 'ucs2' -仅用2个字节编码的Unicode字符。它仅可对BMP（基本多文种平面或第零平面，从U+0000到U+FFFF）进行编码。

  • 'base64' - Base64字符串编码。

  • 'binary' -经使用每个字符的头8位把原始二进制数据编码成字符串的一种途径。这是一个已经被废弃的编码方法。 且为了能让缓冲器对象取代这个编码方法，应避免使用它。在Node的未来版本中也会移除掉这个编码方法。

  • 'hex' - 把每个字节编码成两个十六进制字符。

类：Buffer

Buffer类是一个全局类型，可以直接处理二进制数据。它有多个构造函数。

new Buffer(size)

  • size Number

分配一个拥有size字节的新缓冲器。

new Buffer(array)

  • array Array

分配一个使用array字节序列的新缓冲器。

new Buffer(str, [encoding])

  • str String - 需要编码的字符串
  • encoding String - 使用的编码方式，可选

分配一个包含给定str的新缓冲器。encoding默认为'utf8'。

buf.write(string,[offset], [length], [encoding])

  • string String - 写入缓冲区的字符串
  • offset Number，可选，默认为0
  • length Number，可选
  • encoding String，可选，默认为'utf8'

用给定的编码在offset偏移处写入string到缓冲器中。offset默认为0，encoding默认为'utf-8'。 length是需要写入的字节数。方法返回成功写入的字节数。如果缓冲器没有足够的空间来转载整个字符串，将会写入一个不完整的字符串。length默认为buffer.length- offset。这个方法不会写入不完整的字符。

buf = new Buffer(256);
len = buf.write('\u00bd + \u00bc = \u00be', 0);
console.log(len + " bytes: " + buf.toString('utf8', 0, len));

Buffer._charsWritten会被设置为写入的字符数（有可能和写入的字节数不同）。且在下一次调用buf.write()时重新覆盖这个值。

buf.toString([encoding],[start], [end])

  • encoding String，可选，默认为'utf8'
  • start Number，可选，默认为0
  • end Number，可选

从encoding编码（默认为'utf8'）的缓冲器数据中，截取以start（默认为0）开始、 end（默认为buffer.length）结束的数据，将其解码并返回一个字符串。

见上面的buffer.write()示例

buf[index]

获取和设置位于index的字节值。这个值指向单个字节，所以合法的范围是从0x00到0xFF或0到255。

例如，复制一个ASCII字符串到缓冲器中，每次一个字节：

str = "node.js";
buf = new Buffer(str.length);

for (var i = 0; i < str.length ; i++) {
  buf[i] = str.charCodeAt(i);
}

console.log(buf.toString()); //（译者注：原文这里有误，直接输出buf对象的结果应该是"<Buffer 6e 6f 64 65 2e 6a 73>"）。

// node.js

类方法：Buffer.isBuffer(obj)

  • obj Object
  • Return:Boolean

验证obj是否是个Buffer实例。

类方法：Buffer.byteLength(string, [encoding])

  • string String
  • encoding String，可选，默认为'utf8'
  • Return:Number

给出一个字符串确切字节长度。encoding默认为'utf8'。因为Strting.prototype.length返回的是一个字符串的*字符*个数，所以这两者是有区别的。

示例：

str = '\u00bd + \u00bc = \u00be';

console.log(str + ": " + str.length + " characters, " +
  Buffer.byteLength(str, 'utf8') + " bytes");

// ½ + ¼ = ¾: 9 characters, 12 bytes

buf.length

  • Number

缓冲器的字节大小。注意，这并非是内容所占的大小。length是指缓冲器对象的预分配内存大小。它不会随着内容的改变而改变。

buf = new Buffer(1234);

console.log(buf.length);
buf.write("some string", "ascii", 0);
console.log(buf.length);

// 1234
// 1234

buf.copy(targetBuffer,[targetStart], [sourceStart], [sourceEnd])

  • targetBuffer Buffer object -做为复制目标的缓冲器
  • targetStart Number，可选，默认为0
  • sourceStart Number，可选，默认为0
  • sourceEnd Number，可选，默认为0

在缓冲器之间进行复制。源和目标的区间是可以重叠的。targetStart和sourceStart默认为0。 sourceEnd默认为buffer.length。

示例：构建两个缓冲器，然后把buf1从第16到第19个字节复制到第8个字节开始的buf2中。

buf1 = new Buffer(26);
buf2 = new Buffer(26);

for (var i = 0 ; i < 26 ; i++) {
  buf1[i] = i + 97; // 97 is ASCII a
  buf2[i] = 33; // ASCII !
}

buf1.copy(buf2, 8, 16, 20);
console.log(buf2.toString('ascii', 0, 25));

// !!!!!!!!qrst!!!!!!!!!!!!!

buf.slice([start], [end])

  • start Number，可选，默认为0
  • end Number，可选，默认为0

返回一个新缓冲器，它引用的内存就是原缓冲器从start（默认为0）到end（默认为buffer.length）的索引区间。

改变新缓冲器片段同样会改变原缓冲器中相对应的那块内存！

示例：用ASCII字母表构建一个缓冲器，获取一个新缓冲器片段，然后改变原缓冲器的一个字节。

var buf1 = new Buffer(26);

for (var i = 0 ; i < 26 ; i++) {
  buf1[i] = i + 97; // 97 is ASCII a
}

var buf2 = buf1.slice(0, 3);
console.log(buf2.toString('ascii', 0, buf2.length));
buf1[0] = 33;
console.log(buf2.toString('ascii', 0, buf2.length));

// abc
// !bc

buf.readUInt8(offset,[noAssert])

  • offset Number
  • noAssert Boolean，可选，默认为false
  • Return:Number

从缓冲器的指定偏移处读取一个无符号8位整型。

把noAssert设置为true，就会略过对offset的验证。也就说offset可以超出缓冲器的末尾。默认为false。

示例：

var buf = new Buffer(4);

buf[0] = 0x3;
buf[1] = 0x4;
buf[2] = 0x23;
buf[3] = 0x42;

for (ii = 0; ii < buf.length; ii++) {
  console.log(buf.readUInt8(ii));
}

// 0x3
// 0x4
// 0x23
// 0x42

buf.readUInt16LE(offset,[noAssert])

buf.readUInt16BE(offset,[noAssert])

  • offset Number
  • noAssert Boolean，可选，默认为false
  • Return:Number

以不同的字节顺序从缓冲器的指定偏移处读取一个无符号16位整型。

把noAssert设置为true，就会略过对offset的验证。也就说offset可以超出缓冲器的末尾。默认为false。

示例：

var buf = new Buffer(4);

buf[0] = 0x3;
buf[1] = 0x4;
buf[2] = 0x23;
buf[3] = 0x42;

console.log(buf.readUInt16BE(0));
console.log(buf.readUInt16LE(0));
console.log(buf.readUInt16BE(1));
console.log(buf.readUInt16LE(1));
console.log(buf.readUInt16BE(2));
console.log(buf.readUInt16LE(2));

// 0x0304
// 0x0403
// 0x0423
// 0x2304
// 0x2342
// 0x4223

buf.readUInt32LE(offset,[noAssert])

buf.readUInt32BE(offset,[noAssert])

  • offset Number
  • noAssert Boolean，可选，默认为false
  • Return:Number

以不同的字节顺序从缓冲器的指定偏移处读取一个无符号32位整型。

把noAssert设置为true，就会略过对offset的验证。也就说offset可以超出缓冲器的末尾。默认为false。

示例：

var buf = new Buffer(4);

buf[0] = 0x3;
buf[1] = 0x4;
buf[2] = 0x23;
buf[3] = 0x42;

console.log(buf.readUInt32BE(0));
console.log(buf.readUInt32LE(0));

// 0x03042342
// 0x42230403

buf.readInt8(offset,[noAssert])

  • offset Number
  • noAssert Boolean，可选，默认为false
  • Return:Number

从缓冲器的指定偏移处读取一个有符号8位整型。

把noAssert设置为true，就会略过对offset的验证。也就说offset可以超出缓冲器的末尾。默认为false。

同buffer.readUInt8相比，除了两者的结果被当作成对的有符号补码外，其它都一样。

buf.readInt16LE(offset,[noAssert])

buf.readInt16BE(offset,[noAssert])

  • offset Number
  • noAssert Boolean，可选，默认为false
  • Return:Number

以不同的字节顺序从缓冲器的指定偏移处读取一个有符号16位整型。

把noAssert设置为true，就会略过对offset的验证。也就说offset可以超出缓冲器的末尾。默认为false。

同buffer.readUInt16*相比，除了两者的结果被当作成对的有符号补码外，其它都一样。

buf.readInt32LE(offset,[noAssert])

buf.readInt32BE(offset,[noAssert])

  • offset Number
  • noAssert Boolean，可选，默认为false
  • Return:Number

以不同的字节顺序从缓冲器的指定偏移处读取一个有符号32位整型。

把noAssert设置为true，就会略过对offset的验证。也就说offset可以超出缓冲器的末尾。默认为false。

同buffer.readUInt32*相比，除了两者的结果被当作成对的有符号补码外，其它都一样。

buf.readFloatLE(offset,[noAssert])

buf.readFloatBE(offset,[noAssert])

  • offset Number
  • noAssert Boolean，可选，默认为false
  • Return:Number

以不同的字节顺序从缓冲器的指定偏移处读取一个32位浮点型。

把noAssert设置为true，就会略过对offset的验证。也就说offset可以超出缓冲器的末尾。默认为false。

示例：

var buf = new Buffer(4);

buf[0] = 0x00;
buf[1] = 0x00;
buf[2] = 0x80;
buf[3] = 0x3f;

console.log(buf.readFloatLE(0));

// 0x01

buf.readDoubleLE(offset,[noAssert])

buf.readDoubleBE(offset,[noAssert])

  • offset Number
  • noAssert Boolean，可选，默认为false
  • Return:Number

以不同的字节顺序从缓冲器的指定偏移处读取一个64位双精度型。

把noAssert设置为true，就会略过对offset的验证。也就说offset可以超出缓冲器的末尾。默认为false。

示例：

var buf = new Buffer(8);

buf[0] = 0x55;
buf[1] = 0x55;
buf[2] = 0x55;
buf[3] = 0x55;
buf[4] = 0x55;
buf[5] = 0x55;
buf[6] = 0xd5;
buf[7] = 0x3f;

console.log(buf.readDoubleLE(0));

// 0.3333333333333333

buf.writeUInt8(value,offset, [noAssert])

  • value Number
  • offset Number
  • noAssert Boolean，可选，默认为false

在缓冲器的指定偏移处写入一个value。注意，value必须是一个有效的无符号8位整型。

把noAssert设置为true，就会略过对offset的验证。也就说value可能对该函数来说太大了， offset可能超出缓冲器的末尾，这些都会导致值在不知道的情况下被丢弃（译者注：即不会抛错）。在并不能确保正确的情况下，最好不要设置为true。默认为false。

示例：

var buf = new Buffer(4);
buf.writeUInt8(0x3, 0);
buf.writeUInt8(0x4, 1);
buf.writeUInt8(0x23, 2);
buf.writeUInt8(0x42, 3);

console.log(buf);

// <Buffer 03 04 23 42>

buf.writeUInt16LE(value,offset, [noAssert])

buf.writeUInt16BE(value,offset, [noAssert])

  • value Number
  • offset Number
  • noAssert Boolean，可选，默认为false

以不同的字节顺序在缓冲器的指定偏移处写入一个value。注意，value必须是一个有效的无符号16位整型。

把noAssert设置为true，就会略过对offset的验证。也就说value可能对该函数来说太大了， offset可能超出缓冲器的末尾，这些都会导致值在不知道的情况下被丢弃（译者注：即不会抛错）。在并不能确保正确的情况下，最好不要设置为true。默认为false。

示例：

var buf = new Buffer(4);
buf.writeUInt16BE(0xdead, 0);
buf.writeUInt16BE(0xbeef, 2);

console.log(buf);

buf.writeUInt16LE(0xdead, 0);
buf.writeUInt16LE(0xbeef, 2);

console.log(buf);

// <Buffer de ad be ef>
// <Buffer ad de ef be>

buf.writeUInt32LE(value,offset, [noAssert])

buf.writeUInt32BE(value,offset, [noAssert])

  • value Number
  • offset Number
  • noAssert Boolean，可选，默认为false

以不同的字节顺序在缓冲器的指定偏移处写入一个value。注意，value必须是一个有效的无符号32位整型。

把noAssert设置为true，就会略过对offset的验证。也就说value可能对该函数来说太大了， offset可能超出缓冲器的末尾，这些都会导致值在不知道的情况下被丢弃（译者注：即不会抛错）。在并不能确保正确的情况下，最好不要设置为true。默认为false。

示例：

var buf = new Buffer(4);
buf.writeUInt32BE(0xfeedface, 0);

console.log(buf);

buf.writeUInt32LE(0xfeedface, 0);

console.log(buf);

// <Buffer fe ed fa ce>
// <Buffer ce fa ed fe>

buf.writeInt8(value,offset, [noAssert])

  • value Number
  • offset Number
  • noAssert Boolean，可选，默认为false

在缓冲器的指定偏移处写入一个value。注意，value必须是一个有效的有符号8位整型。

把noAssert设置为true，就会略过对offset的验证。也就说value可能对该函数来说太大了， offset可能超出缓冲器的末尾，这些都会导致值在不知道的情况下被丢弃（译者注：即不会抛错）。在并不能确保正确的情况下，最好不要设置为true。默认为false。

同buffer.writeUInt8相比，除了两者写入缓冲器的值被当作成对的有符号整型补码外，其它都一样。

buf.writeInt16LE(value,offset, [noAssert])

buf.writeInt16BE(value,offset, [noAssert])

  • value Number
  • offset Number
  • noAssert Boolean，可选，默认为false

以不同的字节顺序在缓冲器的指定偏移处写入一个value。注意，value必须是一个有效的有符号16位整型。

把noAssert设置为true，就会略过对offset的验证。也就说value可能对该函数来说太大了， offset可能超出缓冲器的末尾，这些都会导致值在不知道的情况下被丢弃（译者注：即不会抛错）。在并不能确保正确的情况下，最好不要设置为true。默认为false。

同buffer.writeUInt16*相比，除了两者写入缓冲器的值被当作成对的有符号整型补码外，其它都一样。

buf.writeInt32LE(value,offset, [noAssert])

buf.writeInt32BE(value,offset, [noAssert])

  • value Number
  • offset Number
  • noAssert Boolean，可选，默认为false

以不同的字节顺序在缓冲器的指定偏移处写入一个value。注意，value必须是一个有效的有符号32位整型。

把noAssert设置为true，就会略过对offset的验证。也就说value可能对该函数来说太大了， offset可能超出缓冲器的末尾，这些都会导致值在不知道的情况下被丢弃（译者注：即不会抛错）。在并不能确保正确的情况下，最好不要设置为true。默认为false。

同buffer.writeUInt32*相比，除了两者写入缓冲器的值被当作成对的有符号整型补码外，其它都一样。

buf.writeFloatLE(value,offset, [noAssert])

buf.writeFloatBE(value,offset, [noAssert])

  • value Number
  • offset Number
  • noAssert Boolean，可选，默认为false

以不同的字节顺序在缓冲器的指定偏移处写入一个value。注意，value必须是一个有效的32位浮点型。

把noAssert设置为true，就会略过对offset的验证。也就说value可能对该函数来说太大了， offset可能超出缓冲器的末尾，这些都会导致值在不知道的情况下被丢弃（译者注：即不会抛错）。在并不能确保正确的情况下，最好不要设置为true。默认为false。

示例：

var buf = new Buffer(4);
buf.writeFloatBE(0xcafebabe, 0);

console.log(buf);

buf.writeFloatLE(0xcafebabe, 0);

console.log(buf);

// <Buffer 4f 4a fe bb>
// <Buffer bb fe 4a 4f>

buf.writeDoubleLE(value,offset, [noAssert])

buf.writeDoubleBE(value,offset, [noAssert])

  • value Number
  • offset Number
  • noAssert Boolean，可选，默认为false

以不同的字节顺序在缓冲器的指定偏移处写入一个value。注意，value必须是一个有效的64位双精度型。

把noAssert设置为true，就会略过对offset的验证。也就说value可能对该函数来说太大了， offset可能超出缓冲器的末尾，这些都会导致值在不知道的情况下被丢弃（译者注：即不会抛错）。在并不能确保正确的情况下，最好不要设置为true。默认为false。

示例：

var buf = new Buffer(8);
buf.writeDoubleBE(0xdeadbeefcafebabe, 0);

console.log(buf);

buf.writeDoubleLE(0xdeadbeefcafebabe, 0);

console.log(buf);

// <Buffer 43 eb d5 b7 dd f9 5f d7>
// <Buffer d7 5f f9 dd b7 d5 eb 43>

buf.fill(value, [offset],[end])

  • value
  • offset Number，可选
  • end Number，可选

用给定的值填充缓冲器。如果没有给出offset（默认为0）和end（默认为buffer.length），那么会填充整个缓冲器。

var b = new Buffer(50);
b.fill("h");

buffer.INSPECT_MAX_BYTES

  • Number，默认为50

指明当调用buffer.inspect()允许返回的字节数。它可以被用户模块重载。

注意，这个属性只存在于用require('buffer')返回的缓冲器模块中，不存在于全局的缓冲器类或缓冲器实例中。

类：SlowBuffer

这个类主要在内部使用。JavaScript程序必须使用Buffer来代替SlowBuffer。

在服务器生命周期内，为了避免给众多小块内存分配C++缓冲器对象的开销，Node会以8Kb（8192字节）为单元分配内存。如果一个缓冲器小于这个单元，那么会返回一个SlowBuffer对象。如果大于这个单元，那么Node会直接为其分配一个SlowBuffer片（Slab）。（译者注：即可以有效减少碎片的产生）。

02-Node.js—Buffer（缓冲器）
Zhang_wang_yun的博客
04-15 1392
Buffer 本质是一段内存空间，专门用来处理 二进制数据 。
Nodejs——Buffer(缓冲器)
LSH_的个人博客
06-28 2820
Buffer 本质是一段内存空间，专门用来处理。Buffer 是一个类似于数组的。方法将 Buffer 转为字符串。toString 默认是按照。，用于表示固定长度的字节序列。Buffer 可以直接通过。的方式对数据进行处理。编码方式进行转换的。
node Buffer
hhthwx的博客
03-21 806
在说Buffer这个模块之前，先来讨论一下node内存的问题。 我们在代码中声明变量并且赋值时，所使用的对象的内存分配在堆中。如果已申请的对空闲内存不够分配新的对象，将继续申请堆内存，直到堆的大小超过v8限制为止。 为什么v8要限制堆的大小，表层原因因为v8最初为浏览器而设计，不太可能遇到用大量内存的场景。对于网页来说，v8的限制已经绰绰有余。深层原因是垃圾回收机制的限制。 在浏览器中，Ja...
Node.js Buffer深入浅出：二进制数据处理的核心利器
最新发布
2301_81137804的博客
08-06 790
在Node.js中，Buffer是处理二进制数据的核心模块。由于JavaScript早期缺乏对二进制的支持，Node.js通过Buffer类实现了对原始内存的直接分配和操作，使其成为处理TCP流、文件系统操作、图像处理等场景的基石。
node-buffer
zhangyiyang111的博客
03-15 153
buffer 1.概念 ​ Buffer 结构和数组非常像 操作的方法也相似 数组中不能存储二进制的文件 而buffer专门存储二进制的数据 ​ 文件流的写入 网络请求数据处理 javascript 语言不能读取或操作数据流机制 ​ buffer在全局作用域 不需要引入 直接使用 buffer中存储的是二进制的数据 显示的时候 是以16进制显示 ​ buffer中每个元素从00-ff 0-255 buffer 中的每个元素 占用内存的一个字节 8比特 ​ 一个汉字占有三个字节 buff
Node之Buffer
weixin_44016230的博客
11-04 154
创建BUFFER类 BUFFER_compare BUFFER_copy BUFFER_silce BUFFER读取 BUFFER缓冲区合并 BUFFER写入缓存区 Buffer与字符编码 BUFFER转为JSON
node Buffer缓存区常见操作示例
10-17
在Node.js中，Buffer是一个专门用来处理二进制数据的特殊对象，它可以在JavaScript语言中存储二进制数据，类似于C语言中的字符数组。Buffer类在Node.js中是全局可用的，用于与TCP流或文件系统等进行交互，尤其是在...
node buffer操作
sun
03-13 519
Buffer的API非常多，本文仅挑选 比较常用/容易理解 的API进行讲解，包括Buffer实例的创建、比较、连接、拷贝、查找、遍历、类型转换、截取、编码转换等。 创建 new Buffer(array) Buffer.alloc(length) Buffer.allocUnsafe(length) Buffer.from(array) 通过 new Buffer(array) ...
node.js中的buffer.toJSON方法使用说明
10-25
在Node.js环境中，Buffer类是处理二进制数据的核心组件，它用于存储和操作非文本数据，如图像、音频或视频流。`toJSON()`方法是Buffer类的一个实用功能，它能够将Buffer对象转换为JSON格式，这对于序列化和在网络上...
A new dibenzo[g.p]chrysene derivative as an efficient anode buffer for inverted polymer solar cells
02-08
This material shows good hole-transport ability, high thermal stability,.and relatively high HOMO/LUMO, suitable for anode buffer in electronic devices. When 4 nm MeOPhNDBC.was inserted between the ...
node-Buffer(缓冲器)
weixin_43167546的博客
03-27 541
Buffer是一个类似于数组的对象, 用于表示固定长度的字节序列。Buffer本质是一段内存空间, 专门用来处理二进制数据。方法将Buffer转为字符串,注意: 1. 如果修改的数值超过。, 则超过8位数据会被舍弃。Buffer可以直接通过。的方式对数据进行处理。
Node-Buffer（缓冲区）
WFL804203164的博客
01-21 681
Buffer（缓冲区） Buffer的结构和数组很像，操作方法和数组也类似 数组中不能存储二进制文件，而Buffer就是专门用来存放二进制数据的 它的元素为16进制的两位数。一个元素就代表一个字节 所以Buffer中每一个元素的范围都是00-ff之间 00-ff转换成二进制就是00000000-11111111，这也是我们计算机最底层的 一个0或者1，我们称之为1位（bit），8bit = 1byte（字节） 在Buffer中存储的是二进制数据，但是显示的时候都是以16进制显示 Buffer中内存不
node之Buffer
MorningDuGe
04-11 422
TypedArray 因为JavaScript中数字是64位浮点数，例如canvas中获取图片像素值的getImageData方法，其实一个像素值是8位，却要浪费64位存储，现在可用8位的ArrayBuffer： // 创建一个8-byte的ArrayBuffer var b = new ArrayBuffer(8); // 创建一个b的引用，类型是Int32，起始位置在0，结束位置为缓冲区尾...
node之buffer
扫地僧
12-08 467
前置知识 字节 一个字节等于8位 字节是计算机中传输信息的基本单位 一个字节可以表示的最大十进制数是255 每个位只能填0或1 进制 0b二进制 0x十六进制 0o八进制 进制之间的转换 parseInt(‘11’, 2) // 二进制转为十进制 parseInt(‘77’, 8) // 八进制转为十进制 parseInt(‘ff’, 16) // 十六进制转为十进制 (1).toString(2) // 十进制转为二进制 1…toString(16) // 十进制转为十六进制 1…to
Node.js Buffer
司马懿的西山居
09-20 2396
一、Instance1、Buffer.alloc(length[, value]) 声明一个长度为length的字节数组，默认用0填充，否则用value填充。 注意：value的取值范围是[-255,255]，不属于此范围的等价于0。2、Buffer.allocUnsafe(length) 创建一个长度为length的未初始化的字节数组。它比起alloc快的多，但是它返回的是一个未经处理的空间
node Buffer(详细)
qq_26889291的博客
10-29 233
创建Buffer的方法 (1) let buf = Buffer.from('Hey!') (2) let buf = Buffer.alloc(4); //创建4个字节 将Buffer转成字符串 const buf = Buffer.from('Hey!') console.log(buf.toString()) //Hoy! 对Buffer字节进行读改删 //读 const buf = Buffer.from('Hey!') console.log(buf[0]) //72 conso.
【NODE.JS】Buffer
个人学习笔记
11-13 3752
Nodejs： Buffer的笔记，一些f方法
Node.js Buffer(缓冲区)
2401_89536600的博客
12-10 1313
JavaScript 语言自身只有字符串数据类型，没有二进制数据类型。Node.js 中的 Buffer 类是用于处理二进制数据的核心工具，提供了对二进制数据的高效操作。Buffer 类在处理文件操作、网络通信、图像处理等场景中特别有用。
node Buffer和protobuf
12-04
Node.js中的Buffer是一个用于处理二进制数据的全局类。它可以用于存储和操作任何二进制数据，例如文件系统操作、网络流、加密算法等等。而protobuf是一种轻量级的数据交换格式，它可以用于序列化结构化数据，以便在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值