Module Buffer de Node.js
Modules intégrés de Node.jsBuffer est une classe de Node.js utilisée pour gérer des flux de données binaires. Dans les ordinateurs, toutes les données sont finalement stockées et transmises sous forme binaire, et Buffer offre un moyen de traiter efficacement ces données binaires brutes dans Node.js.
Vous pouvez considérer Buffer comme un "conteneur" de taille fixe spécialement conçu pour contenir des données binaires brutes. Contrairement aux tableaux ordinaires de JavaScript, Buffer alloue un bloc de mémoire de taille fixe, ce qui le rend plus efficace lors du traitement de grandes quantités de données binaires.
Pourquoi avons-nous besoin de Buffer ?
Dans le développement web, nous devons souvent traiter diverses données binaires, telles que :
- Opérations de lecture et d'écriture de fichiers
- Transmission de données dans la communication réseau
- Traitement d'images
- Opérations de chiffrement et de déchiffrement
JavaScript a été conçu à l'origine principalement pour les opérations DOM dans les navigateurs, avec une capacité limitée à gérer les données binaires. Node.js, en tant qu'environnement d'exécution côté serveur, a besoin de capacités de traitement de données binaires plus puissantes, c'est pourquoi le module Buffer existe.
Création d'un Buffer
Il existe plusieurs façons de créer un Buffer dans Node.js :
1. Utilisation de Buffer.alloc()
Exemple
const buf1 = Buffer.alloc(10);
console.log(buf1); // <Buffer 00 00 00 00 00 00 00 00 00 00>
2. Utilisation de Buffer.allocUnsafe()
Exemple
// Peut contenir d'anciennes données, donc c'est plus rapide mais moins sûr
const buf2 = Buffer.allocUnsafe(10);
console.log(buf2); // <Le contenu du Buffer est incertain>
3. Création à partir d'un tableau
Exemple
const buf3 = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
console.log(buf3); // <Buffer 62 75 66 66 65 72>
4. Création à partir d'une chaîne
Exemple
const buf4 = Buffer.from('Hello Node.js');
console.log(buf4); // <Buffer 48 65 6c 6c 6f 20 4e 6f 64 65 2e 6a 73>
Méthodes courantes de Buffer
Écriture de données
Exemple
// Écrire une chaîne
buf.write('Hello');
console.log(buf); // <Buffer 48 65 6c 6c 6f>
// Spécifier l'encodage lors de l'écriture
const buf2 = Buffer.alloc(10);
buf2.write('Hello', 'utf8');
console.log(buf2); // <Buffer e4 bd a0 e5 a5 bd 00 00 00 00>
Lecture de données
Exemple
// Lire en tant que chaîne
console.log(buf.toString()); // Hello World
// Lire une partie du contenu
console.log(buf.toString('utf8', 0, 5)); // Hello
Copie d'un Buffer
Exemple
const buf2 = Buffer.from('World');
const buf3 = Buffer.alloc(10);
buf1.copy(buf3, 0); // Copier buf1 au début de buf3
buf2.copy(buf3, 5); // Copier buf2 à la position commençant au 5e octet de buf3
console.log(buf3.toString()); // HelloWorld
Concaténation de Buffers
Exemple
const buf2 = Buffer.from(' ');
const buf3 = Buffer.from('World');
const result = Buffer.concat([buf1, buf2, buf3]);
console.log(result.toString()); // Hello World
Buffer et chaînes de caractères
Les Buffer et les chaînes de caractères peuvent être convertis entre eux, mais il faut faire attention à l'encodage. Les encodages courants sont :
- 'utf8' (par défaut)
- 'ascii'
- 'base64'
- 'hex'
Exemple
Exemple
const str = 'Hello Buffer';
const buf = Buffer.from(str);
// Convertir un Buffer en chaîne
console.log(buf.toString()); // Hello Buffer
// Utiliser différents encodages
console.log(buf.toString('hex')); // 48656c6c6f20427566666572
console.log(buf.toString('base64')); // SGVsbG8gQnVmZmVy
Applications pratiques de Buffer
1. Opérations sur les fichiers
Exemple
// Lire un fichier dans un Buffer
fs.readFile('example.txt', (err, data) => {
if (err) throw err;
console.log(data); // <Buffer ...>
console.log(data.toString()); // Contenu du fichier
});
// Écrire le Buffer dans un fichier
const content = Buffer.from('Bonjour système de fichiers');
fs.writeFile('output.txt', content, (err) => {
if (err) throw err;
console.log('Fichier enregistré');
});
2. Communication réseau
Exemple
http.createServer((req, res) => {
const chunks = [];
req.on('data', (chunk) => {
chunks.push(chunk); // Collecter les morceaux de données
});
req.on('end', () => {
const body = Buffer.concat(chunks); // Combiner tous les morceaux de données
console.log(`Données reçues: ${body.toString()}`);
res.end('Données reçues');
});
}).listen(3000);
3. Traitement d'images
Exemple
const sharp = require('sharp');
// Lire l'image dans un Buffer
fs.readFile('input.jpg', (err, data) => {
if (err) throw err;
// Utiliser sharp pour traiter les données d'image dans un Buffer
sharp(data)
.resize(200, 200)
.toBuffer()
.then(outputBuffer => {
// Écrire le Buffer traité dans un fichier
fs.writeFile('output.jpg', outputBuffer, err => {
if (err) throw err;
console.log('Traitement d'image terminé');
});
});
});
Notes
Gestion de la mémoire: Buffer opère directement sur la mémoire; allouer de grands Buffers peut affecter les performances de l'application.
Sécurité：
Buffer.allocUnsafe()Peut contenir des données sensibles, soyez donc prudent lors de son utilisation.Encodage cohérent: Lors de la conversion entre Buffer et chaîne, veillez à utiliser le même encodage.
Différences entre versions: L'API Buffer des anciennes versions de Node.js (v5.x et antérieures) diffère des versions plus récentes ; il est recommandé d'utiliser l'API la plus récente.
Considérations de performance: Pour le traitement de données à grande échelle, une utilisation appropriée de Buffer peut considérablement améliorer les performances.
Buffer est un module central de Node.js pour la gestion des données binaires. Comprendre ses principes de fonctionnement et ses méthodes d'utilisation est crucial pour développer des applications Node.js efficaces et fiables.
BufferListe des méthodes et propriétés du module
BufferIl s'agit d'un module central de Node.js utilisé pour la gestion des données binaires. Voici les principales méthodes et propriétés du module Buffer :
Propriétés de la classe Buffer
| Propriété/Méthode | Description | Version introduite |
|---|---|---|
| Buffer.poolSize | Taille de l'instance Buffer interne préallouée (en octets), modifiable | 0.11.3 |
| Buffer.from() | Créer un nouveau Buffer à partir d'une chaîne, d'un tableau ou d'un buffer | 5.10.0 |
| Buffer.alloc() | Créer un Buffer initialisé de taille spécifiée | 5.10.0 |
| Buffer.allocUnsafe() | Créer un Buffer non initialisé de taille spécifiée (plus rapide mais non sécurisé) | 5.10.0 |
| Buffer.allocUnsafeSlow() | Créer un Buffer non initialisé (sans utiliser le pool de mémoire partagé) | 5.12.0 |
| Buffer.isBuffer() | Vérifier si un objet est un Buffer | 0.1.101 |
| Buffer.isEncoding() | Vérifier si un encodage est valide | 0.9.1 |
| Buffer.concat() | Combiner un tableau de Buffers | 0.7.11 |
| Buffer.byteLength() | Renvoie la longueur en octets d'une chaîne de caractères | 0.1.90 |
| Buffer.compare() | Compare deux Buffers | 0.11.13 |
Méthodes d'instance de Buffer
| Méthode | Description | Version introduite |
|---|---|---|
| buf.length | Longueur en octets du Buffer | 0.1.90 |
| buf.write() | Écrit une chaîne de caractères dans le Buffer | 0.1.90 |
| buf.toString() | Décode le Buffer en une chaîne de caractères | 0.1.90 |
| buf.toJSON() | Renvoie la représentation JSON du Buffer | 0.9.2 |
| buf.equals() | Vérifier si deux Buffers sont égaux | 0.11.13 |
| buf.compare() | Comparer des Buffers et renvoyer l'ordre de tri | 0.11.13 |
| buf.copy() | Copier les données du Buffer | 0.1.90 |
| buf.slice() | Créer une vue partielle du Buffer | 0.3.0 |
| buf.includes() | Vérifier si le Buffer contient une valeur | 5.3.0 |
| buf.indexOf() | Renvoyer la position de la première occurrence d'une valeur | 1.5.0 |
| buf.lastIndexOf() | Renvoie la position de la dernière occurrence d'une valeur | 6.0.0 |
| buf.fill() | Remplit le Buffer avec une valeur spécifiée | 0.5.0 |
| buf.readUIntLE() | Lit un entier non signé little-endian | 0.5.5 |
| buf.readUIntBE() | Lit un entier non signé big-endian | 0.5.5 |
| buf.readIntLE() | Lit un entier signé little-endian | 0.11.15 |
| buf.readIntBE() | Lit un entier signé big-endian | 0.11.15 |
| buf.readDoubleBE() | Lire un nombre à virgule flottante à double précision 64 bits big-endian | 0.11.15 |
| buf.readDoubleLE() | Lire un nombre à virgule flottante à double précision 64 bits little-endian | 0.11.15 |
| buf.readFloatBE() | Lire un nombre à virgule flottante 32 bits big-endian | 0.11.15 |
| buf.readFloatLE() | Lire un nombre à virgule flottante 32 bits little-endian | 0.11.15 |
| buf.writeUIntLE() | Écrire un entier non signé little-endian | 0.5.5 |
| buf.writeUIntBE() | Écrire un entier non signé big-endian | 0.5.5 |
| buf.writeIntLE() | Écrire un entier signé little-endian | 0.11.15 |
| buf.writeIntBE() | Écrire un entier signé big-endian | 0.11.15 |
| buf.writeDoubleBE() | Écrire un nombre à virgule flottante à double précision 64 bits big-endian | 0.11.15 |
| buf.writeDoubleLE() | Écrire un nombre à virgule flottante à double précision 64 bits little-endian | 0.11.15 |
| buf.writeFloatBE() | Écrire un nombre à virgule flottante 32 bits big-endian | 0.11.15 |
| buf.writeFloatLE() | Écrire un nombre à virgule flottante 32 bits little-endian | 0.11.15 |
| buf.swap16() | Échange l'ordre des octets 16 bits | 5.10.0 |
| buf.swap32() | Échange l'ordre des octets 32 bits | 5.10.0 |
| buf.swap64() | Échange l'ordre des octets 64 bits | 6.3.0 |
| buf.keys() | Crée un itérateur des clés du Buffer | 1.1.0 |
| buf.values() | Crée un itérateur des valeurs du Buffer | 1.1.0 |
| buf.entries() | Crée un itérateur pour [index, byte] | 1.1.0 |
Types d'encodage
Types d'encodage pris en charge par Buffer :
| Encodage | Description |
|---|---|
| utf8 | Caractères Unicode multi-octets |
| utf16le | Caractères Unicode de 2 ou 4 octets |
| latin1 | ISO-8859-1 |
| ascii | Données ASCII sur 7 bits uniquement |
| base64 | Encodage Base64 |
| base64url | Encodage Base64 compatible avec les URL |
| hex | Encodage hexadécimal |
| ucs2 | Alias pour utf16le |
| binaire | Alias pour latin1 (obsolète) |
Exemple
const buf1 = Buffer.alloc(10); // Initialiser un Buffer rempli de zéros
const buf2 = Buffer.from('hello'); // Créer à partir d'une chaîne
const buf3 = Buffer.from([1, 2, 3]); // Créer à partir d'un tableau
// Écrire et lire
buf1.write('Node.js');
console.log(buf1.toString('utf8', 0, 6)); // 'Node.js'
// Comparer les Buffers
const bufA = Buffer.from('A');
const bufB = Buffer.from('B');
console.log(bufA.compare(bufB)); // -1
// Concaténer les Buffers
const concatBuf = Buffer.concat([bufA, bufB]);