Parlons de quelques méthodes importantes du module tampon Node.js

Cet article partagera avec vous un guide complet du tampon Node.js et parlera de quelques méthodes importantes du module Node buffer (Buffer). J'espère qu'il sera utile à tout le monde !

Un flux binaire est une grande collection de données binaires. Étant donné que la taille du flux binaire est généralement assez grande, le flux binaire n'est généralement pas expédié ensemble, mais est divisé en petits morceaux avant l'expédition et envoyé un par un.

Lorsque l'unité de traitement de données cesse temporairement de recevoir d'autres flux de données, les données restantes seront conservées dans le cache jusqu'à ce que l'unité de traitement de données soit prête à recevoir plus de données.

Node.js Les serveurs doivent généralement lire et écrire dans le système de fichiers, et les fichiers sont en fait des flux binaires au niveau du stockage. De plus, Node.js peut également être utilisé avec des flux TCP, permettant aux flux TCP de fournir des flux d'octets fiables de bout en bout pour garantir la communication sur des réseaux Internet peu fiables.

Le flux de données envoyé au récepteur est mis en mémoire tampon jusqu'à ce que le récepteur soit prêt à recevoir plus de données à traiter. C'est ce que fait la partie données temporaires de Node.js : gérer et stocker les données binaires en dehors du moteur V8.

Plongeons dans les différentes utilisations des tampons (Buffer), apprenons-en plus à leur sujet et apprenons à les utiliser dans les programmes Node.js. Buffer）的各种使用方法，了解更多有关它们的信息以及一起学习如何在 Node.js 程序中使用它们吧。

Node.js Buffer 的方法

Node.js 缓冲模块的最大优势，其实就是它是内置于 Node.js 中的，因此我们可以在任何我们想要使用它的地方使用它。

让我们一起浏览一些重要的 Node.js 缓冲模块的方法吧。

Buffer.alloc()

此方法将创建一个新的缓冲区，但是分配的大小不是固定的。当我们调用此方法时，可以自行分配大小（以字节为单位）。

const buf = Buffer.alloc(6)  // 这会创建一个 6 字节的缓冲区

console.log(buf) // <Buffer 00 00 00 00 00 00>

Buffer.byteLength()

如果我们想要获取缓冲区的长度，我们只需调用 Buffer.byteLength() 就行了。

var buf = Buffer.alloc(10)
var buffLen = Buffer.byteLength(buf) // 检查缓冲区长度

console.log(buffLen) // 10

Buffer.compare()

通过使用 Buffer.compare() 我们可以比较两个缓冲区，此方法的返回值是 -1，0，1 中的一个。

译者注：buf.compare(otherBuffer); 这一句调用会返回一个数字 -1，0，1，分别对应 buf 在 otherBuffer 之前，之后或相同。

var buf1 = Buffer.from('Harsh')
var buf2 = Buffer.from('Harsg')
var a = Buffer.compare(buf1, buf2)
console.log(a) // 这会打印 0

var buf1 = Buffer.from('a')
var buf2 = Buffer.from('b')
var a = Buffer.compare(buf1, buf2)
console.log(a) // 这会打印 -1


var buf1 = Buffer.from('b')
var buf2 = Buffer.from('a')
var a = Buffer.compare(buf1, buf2)
console.log(a) // 这会打印 1

Buffer.concat()

顾名思义，我们可以使用此函数连接两个缓冲区。当然，就像字符串一样，我们也可以连接两个以上的缓冲区。

var buffer1 = Buffer.from('x')
var buffer2 = Buffer.from('y')
var buffer3 = Buffer.from('z')
var arr = [buffer1, buffer2, buffer3]

console.log(arr)
/* buffer, !concat [ <Buffer 78>, <Buffer 79>, <Buffer 7a> ] */

// 通过 Buffer.concat 方法连接两个缓冲区
var buf = Buffer.concat(arr)

console.log(buf)
// <Buffer 78 79 7a> concat successful

Buffer.entries()

Buffer.entries() 会用这一缓冲区的内容创建并返回一个 [index, byte] 形式的迭代器。

var buf = Buffer.from('xyz')

for (a of buf.entries()) {
    console.log(a)
    /* 这个会在控制台输出一个有缓冲区位置与内容的字节的数组 [ 0, 120 ][ 1, 121 ][ 2, 122 ] */
}

Buffer.fill()

我们可以使用 Buffer.fill() 这个函数将数据插入或填充到缓冲区中。更多信息请参见下文。

const b = Buffer.alloc(10).fill('a')

console.log(b.toString())
// aaaaaaaaaa

Buffer.includes()

像字符串一样，它将确认缓冲区是否具有该值。我们可以使用 Buffer.includes() 方法来实现这一点，给定方法根据搜索返回一个布尔值，即 true 或 false。

const buf = Buffer.from('this is a buffer')
console.log(buf.includes('this'))
// true

console.log(buf.includes(Buffer.from('a buffer example')))
// false

Buffer.isEncoding()

我们可能知道二进制文件必须进行编码，那么如果我们要检查数据类型是否支持字符编码该怎么办呢？我们可以使用 Buffer.isEncoding() 方法进行确认。如果支持，它将返回 true。

console.log(Buffer.isEncoding('hex'))
// true

console.log(Buffer.isEncoding('utf-8'))
// true

console.log(Buffer.isEncoding('utf/8'))
// false

console.log(Buffer.isEncoding('hey'))
// false

Buffer.slice()

buf.slice() 将用于使用缓冲区的选定元素创建一个新缓冲区 —— 对缓冲区进行切割时，将创建一个新缓冲区，其中包含要在新缓冲区切片中找到的项目的列表。

var a = Buffer.from('uvwxyz');
var b = a.slice(2, 5);

console.log(b.toString());
// wxy

Buffer.swapX()

Buffer.swapX() 用于交换缓冲区的字节顺序。使用 Buffer.swapX() （此处 X 可以为 16, 32, 64）来交换 16 位，32 位和 64 位缓冲区对象的字节顺序。

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// <Buffer 01 02 03 04 05 06 07 08>

// 交换 16 位字节顺序
buf1.swap16()
console.log(buf1)
// <Buffer 02 01 04 03 06 05 08 07>

// 交换 32 位字节顺序
buf1.swap32()
console.log(buf1)
// <Buffer 03 04 01 02 07 08 05 06>

// 交换 64 位字节顺序
buf1.swap64()
console.log(buf1)
// <Buffer 06 05 08 07 02 01 04 03>

Buffer.json()

Méthode Node.js Buffer

Le plus grand avantage du module buffer Node.js est qu'il est intégré à Node.js, nous pouvons donc l'utiliser où nous voulons. où il est utilisé.

🎜Passons en revue quelques méthodes importantes du module de mise en mémoire tampon Node.js. 🎜🎜Buffer.alloc()🎜🎜🎜Cette méthode créera un nouveau tampon, mais la taille allouée n'est pas fixe. Lorsque nous appelons cette méthode, nous pouvons attribuer nous-mêmes la taille (en octets). 🎜

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);

console.log(buf.toJSON());
// {"type":"Buffer", data:[1, 2, 3, 4, 5, 6, 7, 8]}

🎜Buffer.byteLength()🎜🎜🎜Si nous voulons obtenir la longueur du tampon, nous appelons simplement Buffer.byteLength(). 🎜rrreee🎜Buffer.compare()🎜🎜🎜En utilisant Buffer.compare() nous pouvons comparer deux tampons, la valeur de retour de cette méthode est < One de code>-1, 0, 1. 🎜🎜Note du traducteur : buf.compare(otherBuffer); Cet appel renverra un nombre -1, 0, 1 </ code>, correspondant à <code>buf avant, après ou identique à otherBuffer. 🎜rrreee🎜Buffer.concat()🎜🎜🎜Comme son nom l'indique, nous pouvons utiliser cette fonction pour concaténer deux tampons. Bien entendu, tout comme les chaînes, nous pouvons également concaténer plus de deux tampons. 🎜rrreee🎜Buffer.entries()🎜🎜🎜Buffer.entries() créera et renverra un [index, byte] à partir du contenu de ce tampon Iterator de la forme. 🎜rrreee🎜Buffer.fill()🎜🎜🎜Nous pouvons utiliser Buffer.fill() cette fonction pour insérer ou remplir des données dans le tampon. Voir ci-dessous pour plus d'informations. 🎜rrreee🎜Buffer.includes()🎜🎜🎜Comme une chaîne, il confirmera si le tampon a la valeur. Nous pouvons y parvenir en utilisant la méthode Buffer.includes(), où la méthode donnée renvoie une valeur booléenne, soit true ou false, selon la recherche. 🎜rrreee🎜Buffer.isEncoding()🎜🎜🎜Nous savons peut-être que les fichiers binaires doivent être codés, alors que se passe-t-il si nous voulons vérifier si le type de données prend en charge le codage de caractères ? Nous pouvons utiliser la méthode Buffer.isEncoding() pour confirmer. S'il est pris en charge, il renverra true. 🎜rrreee🎜Buffer.slice()🎜🎜🎜buf.slice() sera utilisé pour créer un nouveau buffer en utilisant les éléments sélectionnés du buffer - Quand un tampon est découpé, un nouveau tampon est créé contenant une liste d'éléments à trouver dans la nouvelle tranche de tampon. 🎜rrreee🎜Buffer.swapX()🎜🎜🎜Buffer.swapX() Utilisé pour échanger l'ordre des octets des tampons. Utilisez Buffer.swapX() (où X peut être 16, 32, 64) pour échanger l'ordre des octets des objets tampon 16 bits, 32 bits et 64 bits. . 🎜rrreee🎜Buffer.json()🎜🎜🎜Cela peut nous aider à créer un objet JSON à partir du tampon, et cette méthode renverra un objet tampon JSON, 🎜

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);

console.log(buf.toJSON());
// {"type":"Buffer", data:[1, 2, 3, 4, 5, 6, 7, 8]}

结论

如果我们需要进一步了解并使用 Node.js 的缓冲区，我们需要对缓冲区以及 Node.js 缓冲区的工作原理有更扎实的基础知识。我们还应该了解为什么我们需要使用 Node.js 缓冲区和各种 Node.js 缓冲区方法的使用。

更多node相关知识，请访问：nodejs 教程！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!