Node.js Buffer

Le langage JavaScript lui-même ne possède qu'un type de données chaîne et aucun type de données binaire.

La classe Buffer dans Node.js est un outil essentiel pour la manipulation de données binaires, offrant des opérations efficaces sur les données binaires.

La classe Buffer est particulièrement utile dans des scénarios tels que les opérations sur les fichiers, la communication réseau et le traitement d'images.

Fonctionnalités :

• Données binaires：BufferL'objet est un tableau de taille fixe contenant des données binaires brutes. Chaque élément occupe un octet (8 bits), doncBufferil est adapté au traitement de données binaires, telles que le contenu de fichiers, les paquets réseau, etc.
• Immutabilité: Bien queBufferle contenu de l'objet peut être modifié après sa création, mais sa longueur est fixe et ne peut pas être modifiée dynamiquement.

Buffer et encodages de caractères

Les instances de Buffer sont généralement utilisées pour représenter des séquences de caractères encodés, telles que des données encodées en UTF-8, UCS2, Base64 ou hexadécimal. En utilisant des encodages de caractères explicites, une conversion peut être effectuée entre les instances de Buffer et les chaînes JavaScript ordinaires.

Les encodages de caractères actuellement pris en charge par Node.js incluent :

• ascii- Seules les données ASCII 7 bits sont prises en charge. Cet encodage est très rapide si le bit de poids fort est supprimé.

• utf8- Caractères Unicode encodés sur plusieurs octets. De nombreuses pages web et d'autres formats de documents utilisent UTF-8.

• utf16le- 2 ou 4 octets, caractères Unicode encodés en little-endian. Prend en charge les paires de substitution (U+10000 à U+10FFFF).

• ucs2 - utf16leAlias de .

• base64- Encodage Base64.

• latin1- Un moyen deBufferencoder dans une chaîne encodée sur un octet.

• binary - latin1Alias de .

• hex- Encode chaque octet en deux caractères hexadécimaux.

Création d'une classe Buffer

Buffer fournit les API suivantes pour créer une classe Buffer :

• Buffer.alloc(size[, fill[, encoding]])：Crée un Buffer d'une longueur de size octets, équivalent à allouer size octets d'espace mémoire, chaque valeur d'octet étant 0.
• Buffer.allocUnsafe(size)：Crée un Buffer d'une longueur de size octets, mais le Buffer peut contenir d'anciennes données, ce qui peut affecter le résultat d'exécution, d'où le nom unsafe.
• Buffer.allocUnsafeSlow(size)：Utilisé pour allouer une nouvelle instance de Buffer de la taille donnée, mais sans l'initialiser.
• Buffer.from(array)：Retourne une nouvelle instance de Buffer initialisée avec les valeurs de array (les éléments du tableau passé ne peuvent être que des nombres, sinon ils seront automatiquement écrasés par 0).
• Buffer.from(arrayBuffer[, byteOffset[, length]])：Retourne un Buffer nouvellement créé qui partage la même mémoire que l'ArrayBuffer donné.
• Buffer.from(buffer)：Copie les données de l'instance de Buffer passée et retourne une nouvelle instance de Buffer.
• Buffer.from(string[, encoding])：Crée un Buffer à partir d'une chaîne ; un encodage peut être spécifié, par défaut UTF-8.

Écriture dans un Buffer

Syntaxe

La syntaxe pour écrire dans un buffer Node est la suivante :

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

Parameters

Les paramètres sont décrits comme suit :

• string- La chaîne à écrire dans le buffer.

• offset- La valeur d'index à laquelle le buffer commence à écrire, par défaut à 0.

• length- Le nombre d'octets à écrire, par défaut buffer.length.

• encoding- L'encodage à utiliser. Par défaut 'utf8'.

Écrit la chaîne dans buf à la position offset selon l'encodage de caractères de encoding. Le paramètre length est le nombre d'octets à écrire. Si buf n'a pas assez d'espace pour contenir toute la chaîne, seule une partie de la chaîne sera écrite. Les caractères partiellement décodés ne seront pas écrits.

Valeur de retour

Renvoie la taille réellement écrite. Si l'espace du buffer est insuffisant, seule une partie de la chaîne sera écrite.

Exemple

buf = Buffer.alloc(256);
len = buf.write("www.example.com");

console.log("写入字节数 : "+  len);

Exécutez le code ci-dessus, et le résultat de sortie est :

$node main.js
写入字节数 : 14

Lecture des données à partir d'un Buffer

Syntaxe

La syntaxe pour lire les données d'un buffer Node est la suivante :

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

Parameters

Les paramètres sont décrits comme suit :

• encoding- L'encodage à utiliser. Par défaut 'utf8'.

• start- Spécifie la position d'index à partir de laquelle commencer la lecture, par défaut 0.

• end- La position de fin, par défaut la fin du buffer.

Valeur de retour

Décode les données du buffer et renvoie une chaîne en utilisant l'encodage spécifié.

Exemple

buf = Buffer.alloc(26);
for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97;
}

console.log( buf.toString('ascii'));       // 输出: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5));   //使用 'ascii' 编码, 并输出: abcde
console.log( buf.toString('utf8',0,5));    // 使用 'utf8' 编码, 并输出: abcde
console.log( buf.toString(undefined,0,5)); // 使用默认的 'utf8' 编码, 并输出: abcde

Exécutez le code ci-dessus, et le résultat de sortie est :

$ node main.js
abcdefghijklmnopqrstuvwxyz
abcde
abcde
abcde

Conversion d'un Buffer en objet JSON

Syntaxe

Le format de syntaxe de la fonction pour convertir un Buffer Node en objet JSON est le suivant :

buf.toJSON()

Lors de la conversion en chaîne d'une instance de Buffer,JSON.stringify()cette méthode sera implicitement appelée.toJSON()。

Valeur de retour

Renvoie un objet JSON.

Exemple

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);

// 输出: {"type":"Buffer","data":[1,2,3,4,5]}
console.log(json);

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ?
    Buffer.from(value.data) :
    value;
});

// 输出: <Buffer 01 02 03 04 05>
console.log(copy);

Exécutez le code ci-dessus, et le résultat de sortie est :

{"type":"Buffer","data":[1,2,3,4,5]}
<Buffer 01 02 03 04 05>

Concaténation de Buffer

Syntaxe

La syntaxe de concaténation de buffer Node est la suivante :

Buffer.concat(list[, totalLength])

Parameters

Les paramètres sont décrits comme suit :

• list- Une liste de type tableau d'objets Buffer à concaténer.

• totalLength- Spécifie la longueur totale de l'objet Buffer concaténé.

Valeur de retour

Renvoie un nouvel objet Buffer formé en concaténant plusieurs membres.

Exemple

var buffer1 = Buffer.from(('Example'));
var buffer2 = Buffer.from(('www.example.com'));
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 内容: " + buffer3.toString());

Exécutez le code ci-dessus, et le résultat de sortie est :

buffer3 内容: Examplewww.example.com

Comparaison de Buffer

Syntaxe

La syntaxe de la fonction pour la comparaison de Buffer Node est la suivante. Cette méthode a été introduite dans Node.js v0.12.2 :

buf.compare(otherBuffer);

Parameters

Les paramètres sont décrits comme suit :

• otherBuffer- avecbufun autre objet Buffer comparé à l'objet.

Valeur de retour

Renvoie un nombre indiquant sibufest dansotherBufferavant, après ou identique.

Exemple

var buffer1 = Buffer.from('ABC');
var buffer2 = Buffer.from('ABCD');
var result = buffer1.compare(buffer2);

if(result < 0) {
   console.log(buffer1 + " 在 " + buffer2 + "之前");
}else if(result == 0){
   console.log(buffer1 + " 与 " + buffer2 + "相同");
}else {
   console.log(buffer1 + " 在 " + buffer2 + "之后");
}

Exécutez le code ci-dessus, et le résultat de sortie est :

ABC在ABCD之前

Copie de Buffer

Syntaxe

La syntaxe de copie de buffer Node est la suivante :

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

Parameters

Les paramètres sont décrits ci-dessous :

• targetBuffer- L'objet Buffer à copier.

• targetStart- Nombre, facultatif, par défaut : 0

• sourceStart- Nombre, facultatif, par défaut : 0

• sourceEnd- Nombre, facultatif, par défaut : buffer.length

Valeur de retour

Aucune valeur de retour.

Exemple

var buf1 = Buffer.from('abcdefghijkl');
var buf2 = Buffer.from('EXAMPLE');

//将 buf2 插入到 buf1 指定位置上
buf2.copy(buf1, 2);

console.log(buf1.toString());

L'exécution du code ci-dessus produit le résultat suivant :

abEXAMPLEijkl

Tranche de Buffer

La syntaxe de découpage de buffer Node est la suivante :

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

Parameters

Les paramètres sont décrits ci-dessous :

• start- Nombre, facultatif, par défaut : 0

• end- Nombre, facultatif, par défaut : buffer.length

Valeur de retour

Renvoie un nouveau buffer qui pointe vers la même mémoire que l'ancien buffer, mais découpé depuis l'index start jusqu'à end.

Exemple

var buffer1 = Buffer.from('example');
// 剪切缓冲区
var buffer2 = buffer1.slice(0,2);
console.log("buffer2 content: " + buffer2.toString());

L'exécution du code ci-dessus produit le résultat suivant :

buffer2 content: ru

Longueur du Buffer

Syntaxe

La syntaxe pour calculer la longueur d'un buffer Node est la suivante :

buf.length;

Valeur de retour

Renvoie la longueur mémoire occupée par l'objet Buffer.

Exemple

var buffer = Buffer.from('www.example.com');
//  缓冲区长度
console.log("buffer length: " + buffer.length);

L'exécution du code ci-dessus produit le résultat suivant :

buffer length: 14

Manuel de référence des méthodes

Ce qui suit liste les méthodes couramment utilisées du module Buffer de Node.js (notez que certaines méthodes ne sont pas disponibles dans les versions plus anciennes) :

const buf = Buffer.allocUnsafe(6);

buf.writeUIntLE(0x1234567890ab, 0, 6);

// 输出: <Buffer ab 90 78 56 34 12>
console.log(buf);

const buf = Buffer.allocUnsafe(6);

buf.writeUIntBE(0x1234567890ab, 0, 6);

// 输出: <Buffer 12 34 56 78 90 ab>
console.log(buf);