Un tampon est un emplacement spécifique dans la mémoire brute. Il sert d'espace de stockage temporaire pour les données binaires excédentaires que l'unité de traitement ne peut accepter à ce moment précis.
Node.js inclut une classe Buffer. Il peut traiter des données binaires lors de la gestion des flux TCP (Transfer Control Protocol) et des opérations de lecture-écriture sur un système de fichiers.
Apprenez à créer, lire et modifier le contenu d'un tampon.
Création d'un tampon
Pour créer un Buffer dans Node.js, vous utiliserez le allouer() ou depuis() méthodes. Le allouer() La méthode crée un nouveau tampon, en spécifiant sa taille lors de la création comme premier et seul paramètre requis. C'est utile lorsque vous n'avez pas de données à stocker au moment de la création du tampon.
Spécifiez le paramètre de taille de tampon en octets lorsque vous créez un tampon avec le allouer() méthode. Par exemple:
constante buf = Buffer.alloc(8);
console.log (buf);
// sortir:
La classe Buffer ajoute automatiquement des zéros comme valeurs d'espace réservé pour les nouvelles données lorsque vous la créez avec la allouer() méthode.
La classe Buffer exprime chaque valeur 0 comme 00, en utilisant le format hexadécimal. Dans cet exemple, il contient un total de huit valeurs.
Pour initialiser le Buffer avec différentes valeurs d'espace réservé, passez une seconde remplir paramètre:
constante buf_filled = Buffer.alloc(8, 5);
console.log (buf_filled);
// sortir:
Cet objet cite une partie en mémoire qui stocke 8 octets de la valeur 05. Notez que bien que vous ayez passé un nombre comme remplir paramètre, les tampons stockent uniquement les données en binaire.
Après avoir alloué de la mémoire au tampon, écrivez des données en appelant le écrire() méthode:
constante buf = Buffer.alloc(8);buf.écrire("v", "utf-8");
console.log (buff)
// sortir:
buf.écrire("Virginie","utf-8");
console.log (buff)
// sortir:
Le écrire() utilise l'encodage de caractères pour convertir le premier paramètre, en utilisant utf-8 puis écrit la chaîne dans le Buffer. L'ajout d'un deuxième caractère à la chaîne remplira le deuxième octet.
Pour extraire des données de types de données existants tels que des chaînes ou des tableaux, utilisez la depuis() méthode. Cette méthode crée des tampons à partir de chaînes et de tableaux.
Par exemple:
// Chaîne
constante stringBuf = Buffer.from('chaîne')
console.log (stringBuf)
// sortir:
// Déployer
constante arrayBuf = Buffer.from([97, 114, 114, 97, 121], 'hexagone')
console.log (tableauBuf);
// sortir:
Le depuis() La méthode prend l'entrée comme premier paramètre, calcule le nombre d'octets dont elle a besoin pour encoder les données, puis envoie le résultat au Buffer. En fournissant un autre format d'encodage comme deuxième paramètre, vous pouvez remplacer l'encodage par défaut (UTF-8).
Passer des numéros au depuis() méthode entraînera une erreur.
Lecture d'un tampon
Bien que les tampons soient similaires aux tableaux, ils ne sont pas redimensionnables et peuvent gérer données informatiques binaires grâce aux méthodes intégrées.
La classe Buffer nous permet de lire des octets individuels de ses données en utilisant la syntaxe entre crochets de JavaScript.
Par exemple:
constante monBuf = Buffer.de('Exploiter');
console.enregistrer(MonBuf[1]);
// sortie: 105console.enregistrer(MonBuf[3]);
// sortie: 101
console.enregistrer(MonBuf[5]);
// sortie: non définie
Le bloc de code ci-dessus utilise la syntaxe entre crochets pour obtenir les valeurs des premier et troisième octets dans leur représentation décimale. Tenter d'obtenir un octet invalide entraînera un indéfini erreur.
Pour accéder à toutes ses données, la classe Buffer est livrée avec des méthodes versJSON() et toString(), qui obtiennent le contenu dans deux formats différents.
Le toString() La méthode génère une chaîne comme contenu du tampon :
constante monBuf = Buffer.de('Exploiter');
console.enregistrer(monBuf.toString());
// sortie: 'Mien'constante nombreBuf = Buffer.from([123]);
console.enregistrer(nombreBuf.toString())
// sortir: '{'
constante videBuf = Buffer.alloc(5);
console.enregistrer(videBuf.toString());
// sortie: '\\x00\\x00\\x00\\x00\\x00'
Le premier appel initialise le Buffer avec la valeur "Exploiter”, que l'appel à toString réplique. Le deuxième exemple utilise un tableau single-int pour l'initialisation, qui a une représentation sous forme de chaîne comme "{" personnage. Dans le dernier cas, un Buffer avec cinq valeurs nulles renvoie la chaîne "\x00\x00\x00\x00\x00”. La chaîne \x00 est la représentation hexadécimale de null.
Le toString() La méthode génère toujours le résultat au format chaîne, quel que soit le type de données avec lequel vous initialisez le tampon.
Le .toJSON() renvoie la représentation décimale des données du Buffer, quelles que soient les données que vous avez utilisées pour initialiser le Buffer.
Par exemple:
constante monBuf = Buffer.de('Exploiter');
console.enregistrer(monBuf.toJSON());
// sortir: { taper: 'Amortir', données: [ 77, 105, 110, 101 ] }
La sortie JSON a une taper propriété d'une valeur de Amortir pour indiquer son origine. Sa propriété data stocke un tableau de décimales qui représentent le tableau d'octets d'origine.
Modification d'un tampon
Semblable à l'accès aux octets individuels d'un tampon, vous pouvez également modifier des octets individuels du contenu d'un tampon en utilisant la syntaxe des crochets.
Lorsque vous utilisez la syntaxe entre crochets pour modifier un contenu individuel, vous ne pouvez attribuer que la représentation décimale de la valeur.
Par exemple:
monBuf[0] = 70
console.enregistrer(monBuf.toString())
// sortie: 'Bien'
Étant donné que les tampons sont des données binaires, vous ne pouvez pas attribuer une chaîne à une partie spécifique d'un tampon. Si vous essayez de définir un octet individuel sur une chaîne, Buffer le traduira en un caractère nul.
Par exemple:
monBuf[0] = 'F';
console.enregistrer(monBuf.toString());
// sortie: '\\x00ine'Vous pouvez également modifier tout le contenu d'un tampon à l'aide de la écrire() méthode.
Envisagez d'insérer un index en dehors de la longueur du tampon. Plutôt que de renvoyer une erreur, Buffer ignore l'index invalide et conserve intact le contenu original de Buffer.
Par exemple, essayez de définir le cinquième élément de monBuf pour r via sa représentation décimale de 114:
monBuf[4] = 114 ;
console.enregistrer(monBuf.toString());
// sortie: 'Mien'
Remarquez que le toString() la méthode renvoie la même valeur 'Exploiter'.
Étant donné que vous ne pouvez pas redimensionner un tampon, essayer d'écrire plus de données qu'il ne peut en contenir entraînera la suppression des données supplémentaires. Par exemple:
constante buf1 = Buffer.alloc(5)
buf1.écrire('nombre');
console.enregistrer(buf1.toString())
// sortie: 'nombre'
En utilisant le toString() méthode pour confirmer les données du tampon, elle renvoie 'nombre' plutôt que 'nombre'. Quel est l'argument inséré à l'intérieur du écrire() méthode.
Les tampons écrivent en série en commençant à l'index zéro. Le écrire() La méthode ajoute en série des octets à un tampon, en écrasant toutes les données précédentes.
Par exemple:
constante buf2 = Buffer.alloc(6);buf2.écrire('membre');
console.enregistrer(buf2.toString())
// sortie: 'membre'
buf2.écrire('Salut');
console.enregistrer(buf2.toString());
// sortie: 'himber'
Le code ci-dessus crée un tampon de six octets et ajoute la chaîne "membre" à l'aide de la écrire() méthode.
Il met ensuite à jour le tampon avec un nouveau contenu qui occupe moins d'espace mémoire que le contenu précédent.
Cela entraîne la création d'une nouvelle chaîne avec les deux premiers octets écrasés et les octets restants laissés inchangés.
De nombreuses API et structures de données utilisent des tampons
Vous savez maintenant comment créer un tampon, y écrire, lire son contenu et le modifier avec les méthodes appropriées.
Il existe plusieurs autres méthodes disponibles pour travailler avec la classe Node.js Buffer.
Vous devez connaître ces méthodes et comprendre les tampons pour comprendre le fonctionnement de différents concepts tels que les flux et les systèmes de fichiers.