Buffer

[Stable : 2 - Stable]

Les objets Buffer sont utilisés pour représenter une séquence de bytes de longueur fixe. De nombreuses API Node.js prennent en charge les Buffer.

La classe Buffer est une sous-classe de la classe Uint8Array de JavaScript et l'étend avec des méthodes couvrant des cas d'utilisation supplémentaires. Les API Node.js acceptent également les Uint8Array bruts partout où les Buffer sont supportés.

Bien que la classe Buffer soit disponible dans la portée globale, il est toujours recommandé de la référencer explicitement via une instruction import ou require.

ESMCJS

import { Buffer } from 'node:buffer'

// Crée un Buffer rempli de zéros de longueur 10.
const buf1 = Buffer.alloc(10)

// Crée un Buffer de longueur 10,
// rempli de bytes ayant tous la valeur `1`.
const buf2 = Buffer.alloc(10, 1)

// Crée un buffer non initialisé de longueur 10.
// Ceci est plus rapide que d'appeler Buffer.alloc() mais l'instance
// Buffer retournée peut contenir d'anciennes données qui doivent être
// écrasées à l'aide de fill(), write(), ou d'autres fonctions qui remplissent le contenu du Buffer.
const buf3 = Buffer.allocUnsafe(10)

// Crée un Buffer contenant les bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3])

// Crée un Buffer contenant les bytes [1, 1, 1, 1] – les entrées
// sont toutes tronquées en utilisant `(value & 255)` pour s'adapter à la plage 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Crée un Buffer contenant les bytes encodés en UTF-8 pour la chaîne 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (en notation hexadécimale)
// [116, 195, 169, 115, 116] (en notation décimale)
const buf6 = Buffer.from('tést')

// Crée un Buffer contenant les bytes Latin-1 [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1')

const { Buffer } = require('node:buffer')

// Crée un Buffer rempli de zéros de longueur 10.
const buf1 = Buffer.alloc(10)

// Crée un Buffer de longueur 10,
// rempli de bytes ayant tous la valeur `1`.
const buf2 = Buffer.alloc(10, 1)

// Crée un buffer non initialisé de longueur 10.
// Ceci est plus rapide que d'appeler Buffer.alloc() mais l'instance
// Buffer retournée peut contenir d'anciennes données qui doivent être
// écrasées à l'aide de fill(), write(), ou d'autres fonctions qui remplissent le contenu du Buffer.
const buf3 = Buffer.allocUnsafe(10)

// Crée un Buffer contenant les bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3])

// Crée un Buffer contenant les bytes [1, 1, 1, 1] – les entrées
// sont toutes tronquées en utilisant `(value & 255)` pour s'adapter à la plage 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Crée un Buffer contenant les bytes encodés en UTF-8 pour la chaîne 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (en notation hexadécimale)
// [116, 195, 169, 115, 116] (en notation décimale)
const buf6 = Buffer.from('tést')

// Crée un Buffer contenant les bytes Latin-1 [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1')

Tampons et encodage de caractères

[Historique]

Version	Modifications
v15.7.0, v14.18.0	Introduction de l'encodage `base64url`.
v6.4.0	Introduction de `latin1` comme alias pour `binary`.
v5.0.0	Suppression des encodages obsolètes `raw` et `raws`.

Lors de la conversion entre des Buffer et des chaînes de caractères, un encodage de caractères peut être spécifié. Si aucun encodage de caractères n'est spécifié, UTF-8 sera utilisé par défaut.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('hello world', 'utf8')

console.log(buf.toString('hex'))
// Affiche : 68656c6c6f20776f726c64
console.log(buf.toString('base64'))
// Affiche : aGVsbG8gd29ybGQ=

console.log(Buffer.from('fhqwhgads', 'utf8'))
// Affiche : <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'))
// Affiche : <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>

const { Buffer } = require('node:buffer')

const buf = Buffer.from('hello world', 'utf8')

console.log(buf.toString('hex'))
// Affiche : 68656c6c6f20776f726c64
console.log(buf.toString('base64'))
// Affiche : aGVsbG8gd29ybGQ=

console.log(Buffer.from('fhqwhgads', 'utf8'))
// Affiche : <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'))
// Affiche : <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>

Les tampons Node.js acceptent toutes les variations de casse des chaînes d'encodage qu'ils reçoivent. Par exemple, UTF-8 peut être spécifié comme 'utf8', 'UTF8' ou 'uTf8'.

Les encodages de caractères actuellement pris en charge par Node.js sont les suivants :

'utf8' (alias : 'utf-8') : caractères Unicode codés sur plusieurs octets. De nombreuses pages Web et autres formats de documents utilisent UTF-8. Il s'agit de l'encodage de caractères par défaut. Lors du décodage d'un Buffer en une chaîne de caractères ne contenant pas exclusivement des données UTF-8 valides, le caractère de remplacement Unicode U+FFFD � sera utilisé pour représenter ces erreurs.
'utf16le' (alias : 'utf-16le') : caractères Unicode codés sur plusieurs octets. Contrairement à 'utf8', chaque caractère de la chaîne sera encodé en utilisant 2 ou 4 octets. Node.js ne prend en charge que la variante little-endian de UTF-16.
'latin1' : Latin-1 signifie ISO-8859-1. Cet encodage de caractères ne prend en charge que les caractères Unicode de U+0000 à U+00FF. Chaque caractère est encodé en utilisant un seul octet. Les caractères qui ne rentrent pas dans cette plage sont tronqués et seront mappés à des caractères de cette plage.

La conversion d'un Buffer en une chaîne de caractères à l'aide de l'un des éléments ci-dessus est appelée décodage, et la conversion d'une chaîne de caractères en Buffer est appelée encodage.

Node.js prend également en charge les encodages binaires-texte suivants. Pour les encodages binaires-texte, la convention de nommage est inversée : la conversion d'un Buffer en une chaîne de caractères est généralement appelée encodage, et la conversion d'une chaîne de caractères en Buffer est appelée décodage.

'base64' : encodage Base64. Lors de la création d'un Buffer à partir d'une chaîne de caractères, cet encodage acceptera également correctement « l'alphabet sécurisé pour les URL et les noms de fichiers » tel que spécifié dans RFC 4648, section 5. Les caractères d'espacement tels que les espaces, les tabulations et les nouvelles lignes contenus dans la chaîne encodée en base64 sont ignorés.
'base64url' : encodage base64url tel que spécifié dans RFC 4648, section 5. Lors de la création d'un Buffer à partir d'une chaîne de caractères, cet encodage acceptera également correctement les chaînes encodées en base64 régulières. Lors de l'encodage d'un Buffer en une chaîne de caractères, cet encodage omettra le rembourrage.
'hex' : encoder chaque octet en deux caractères hexadécimaux. Une troncature des données peut se produire lors du décodage de chaînes de caractères qui ne consistent pas exclusivement en un nombre pair de caractères hexadécimaux. Voir ci-dessous pour un exemple.

Les encodages de caractères hérités suivants sont également pris en charge :

'ascii' : pour les données ASCII 7 bits uniquement. Lors de l'encodage d'une chaîne de caractères en Buffer, cela équivaut à l'utilisation de 'latin1'. Lors du décodage d'un Buffer en une chaîne de caractères, l'utilisation de cet encodage annulera en outre le bit le plus élevé de chaque octet avant le décodage en 'latin1'. En général, il n'y a aucune raison d'utiliser cet encodage, car 'utf8' (ou, si les données sont connues pour être toujours uniquement ASCII, 'latin1') sera un meilleur choix lors de l'encodage ou du décodage de texte uniquement ASCII. Il n'est fourni que pour la compatibilité descendante.
'binary' : alias de 'latin1'. Le nom de cet encodage peut être très trompeur, car tous les encodages répertoriés ici convertissent entre les chaînes de caractères et les données binaires. Pour la conversion entre les chaînes de caractères et les Buffer, 'utf8' est généralement le bon choix.
'ucs2', 'ucs-2' : alias de 'utf16le'. UCS-2 faisait référence à une variante de UTF-16 qui ne prenait pas en charge les caractères dont les points de code étaient supérieurs à U+FFFF. Dans Node.js, ces points de code sont toujours pris en charge.

ESMCJS

import { Buffer } from 'node:buffer'

Buffer.from('1ag123', 'hex')
// Affiche <Buffer 1a>, données tronquées lorsque la première valeur non hexadécimale
// ('g') rencontrée.

Buffer.from('1a7', 'hex')
// Affiche <Buffer 1a>, données tronquées lorsque les données se terminent par un seul chiffre ('7').

Buffer.from('1634', 'hex')
// Affiche <Buffer 16 34>, toutes les données représentées.

const { Buffer } = require('node:buffer')

Buffer.from('1ag123', 'hex')
// Affiche <Buffer 1a>, données tronquées lorsque la première valeur non hexadécimale
// ('g') rencontrée.

Buffer.from('1a7', 'hex')
// Affiche <Buffer 1a>, données tronquées lorsque les données se terminent par un seul chiffre ('7').

Buffer.from('1634', 'hex')
// Affiche <Buffer 16 34>, toutes les données représentées.

Les navigateurs Web modernes suivent la norme d'encodage WHATWG qui associe à la fois 'latin1' et 'ISO-8859-1' à 'win-1252'. Cela signifie que lorsque vous faites quelque chose comme http.get(), si le jeu de caractères renvoyé est l'un de ceux répertoriés dans la spécification WHATWG, il est possible que le serveur ait réellement renvoyé des données encodées en 'win-1252', et l'utilisation de l'encodage 'latin1' peut décoder incorrectement les caractères.

Tampons et TypedArrays

[Historique]

Version	Modifications
v3.0.0	La classe `Buffer` hérite désormais de `Uint8Array`.

Les instances de Buffer sont également des instances de Uint8Array et de TypedArray JavaScript. Toutes les méthodes TypedArray sont disponibles sur les Buffer. Cependant, il existe des incompatibilités subtiles entre l'API Buffer et l'API TypedArray.

En particulier :

Alors que TypedArray.prototype.slice() crée une copie d'une partie du TypedArray, Buffer.prototype.slice() crée une vue sur le Buffer existant sans copie. Ce comportement peut être surprenant et n'existe que pour la compatibilité descendante. TypedArray.prototype.subarray() peut être utilisé pour obtenir le comportement de Buffer.prototype.slice() sur les Buffer et les autres TypedArray et devrait être préféré.
buf.toString() est incompatible avec son équivalent TypedArray.
Un certain nombre de méthodes, par exemple buf.indexOf(), prennent en charge des arguments supplémentaires.

Il existe deux manières de créer de nouvelles instances TypedArray à partir d'un Buffer :

Passer un Buffer à un constructeur TypedArray copiera le contenu du Buffer, interprété comme un tableau d'entiers, et non comme une séquence d'octets du type cible.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, 2, 3, 4])
const uint32array = new Uint32Array(buf)

console.log(uint32array)

// Affiche : Uint32Array(4) [ 1, 2, 3, 4 ]

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, 2, 3, 4])
const uint32array = new Uint32Array(buf)

console.log(uint32array)

// Affiche : Uint32Array(4) [ 1, 2, 3, 4 ]

Passer le ArrayBuffer sous-jacent du Buffer créera un TypedArray qui partage sa mémoire avec le Buffer.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('hello', 'utf16le')
const uint16array = new Uint16Array(buf.buffer, buf.byteOffset, buf.length / Uint16Array.BYTES_PER_ELEMENT)

console.log(uint16array)

// Affiche : Uint16Array(5) [ 104, 101, 108, 108, 111 ]

const { Buffer } = require('node:buffer')

const buf = Buffer.from('hello', 'utf16le')
const uint16array = new Uint16Array(buf.buffer, buf.byteOffset, buf.length / Uint16Array.BYTES_PER_ELEMENT)

console.log(uint16array)

// Affiche : Uint16Array(5) [ 104, 101, 108, 108, 111 ]

Il est possible de créer un nouveau Buffer qui partage la même mémoire allouée qu'une instance TypedArray en utilisant la propriété .buffer de l'objet TypedArray de la même manière. Buffer.from() se comporte comme new Uint8Array() dans ce contexte.

ESMCJS

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

arr[0] = 5000
arr[1] = 4000

// Copie le contenu de `arr`.
const buf1 = Buffer.from(arr)

// Partage la mémoire avec `arr`.
const buf2 = Buffer.from(arr.buffer)

console.log(buf1)
// Affiche : <Buffer 88 a0>
console.log(buf2)
// Affiche : <Buffer 88 13 a0 0f>

arr[1] = 6000

console.log(buf1)
// Affiche : <Buffer 88 a0>
console.log(buf2)
// Affiche : <Buffer 88 13 70 17>

const { Buffer } = require('node:buffer')

const arr = new Uint16Array(2)

arr[0] = 5000
arr[1] = 4000

// Copie le contenu de `arr`.
const buf1 = Buffer.from(arr)

// Partage la mémoire avec `arr`.
const buf2 = Buffer.from(arr.buffer)

console.log(buf1)
// Affiche : <Buffer 88 a0>
console.log(buf2)
// Affiche : <Buffer 88 13 a0 0f>

arr[1] = 6000

console.log(buf1)
// Affiche : <Buffer 88 a0>
console.log(buf2)
// Affiche : <Buffer 88 13 70 17>

Lors de la création d'un Buffer à l'aide de .buffer d'un TypedArray, il est possible d'utiliser seulement une partie du ArrayBuffer sous-jacent en passant les paramètres byteOffset et length.

ESMCJS

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(20)
const buf = Buffer.from(arr.buffer, 0, 16)

console.log(buf.length)
// Affiche : 16

const { Buffer } = require('node:buffer')

const arr = new Uint16Array(20)
const buf = Buffer.from(arr.buffer, 0, 16)

console.log(buf.length)
// Affiche : 16

Buffer.from() et TypedArray.from() ont des signatures et des implémentations différentes. Plus précisément, les variantes TypedArray acceptent un deuxième argument qui est une fonction de mappage appelée sur chaque élément du tableau typé :

TypedArray.from(source[, mapFn[, thisArg]])

La méthode Buffer.from(), cependant, ne prend pas en charge l'utilisation d'une fonction de mappage :

Tampons et itération

Les instances de Buffer peuvent être itérées à l'aide de la syntaxe for..of :

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, 2, 3])

for (const b of buf) {
  console.log(b)
}
// Affiche :
//   1
//   2
//   3

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, 2, 3])

for (const b of buf) {
  console.log(b)
}
// Affiche :
//   1
//   2
//   3

De plus, les méthodes buf.values(), buf.keys() et buf.entries() peuvent être utilisées pour créer des itérateurs.

Classe : `Blob`

[Historique]

Version	Modifications
v18.0.0, v16.17.0	N'est plus expérimental.
v15.7.0, v14.18.0	Ajouté dans : v15.7.0, v14.18.0

Un Blob encapsule des données brutes immuables qui peuvent être partagées en toute sécurité entre plusieurs threads de travail.

`new buffer.Blob([sources[, options]])`

[Historique]

Version	Modifications
v16.7.0	L'option standard `endings` a été ajoutée pour remplacer les terminaisons de ligne, et l'option non standard `encoding` a été supprimée.
v15.7.0, v14.18.0	Ajouté dans : v15.7.0, v14.18.0

sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> Un tableau d'objets string, <ArrayBuffer>, <TypedArray>, <DataView>, ou <Blob>, ou toute combinaison de ces objets, qui seront stockés dans le Blob.
options <Object>
- endings <string> L'une des valeurs 'transparent' ou 'native'. Lorsqu'il est défini sur 'native', les terminaisons de ligne dans les parties source de la chaîne seront converties en la terminaison de ligne native de la plateforme, comme spécifié par require('node:os').EOL.
- type <string> Le type de contenu du Blob. L'intention est que type indique le type de média MIME des données, mais aucune validation du format du type n'est effectuée.

Crée un nouvel objet Blob contenant une concaténation des sources données.

Les sources <ArrayBuffer>, <TypedArray>, <DataView> et <Buffer> sont copiées dans le Blob et peuvent donc être modifiées en toute sécurité après la création du Blob.

Les sources de chaînes sont codées en séquences d'octets UTF-8 et copiées dans le Blob. Les paires de caractères de substitution non appariées dans chaque partie de la chaîne seront remplacées par des caractères de remplacement Unicode U+FFFD.

`blob.arrayBuffer()`

Ajouté dans : v15.7.0, v14.18.0

Retourne : <Promise>

Retourne une promesse qui se résout avec un <ArrayBuffer> contenant une copie des données du Blob.

`blob.bytes()`

Ajouté dans : v22.3.0, v20.16.0

La méthode blob.bytes() retourne l'octet de l'objet Blob sous forme de Promise\<Uint8Array\>.

const blob = new Blob(['hello'])
blob.bytes().then(bytes => {
  console.log(bytes) // Affiche : Uint8Array(5) [ 104, 101, 108, 108, 111 ]
})

`blob.size`

Ajouté dans : v15.7.0, v14.18.0

La taille totale du Blob en octets.

`blob.slice([start[, end[, type]]])`

Ajouté dans : v15.7.0, v14.18.0

start <number> L'index de départ.
end <number> L'index de fin.
type <string> Le type de contenu pour le nouveau Blob

Crée et retourne un nouveau Blob contenant un sous-ensemble des données de cet objet Blob. Le Blob original n'est pas modifié.

`blob.stream()`

Ajouté dans : v16.7.0

Retourne : <ReadableStream>

Retourne un nouveau ReadableStream qui permet de lire le contenu du Blob.

`blob.text()`

Ajouté dans : v15.7.0, v14.18.0

Retourne : <Promise>

Retourne une promesse qui se résout avec le contenu du Blob décodé en chaîne UTF-8.

`blob.type`

Ajouté dans : v15.7.0, v14.18.0

Type : <string>

Le type de contenu du Blob.

Objets `Blob` et `MessageChannel`

Une fois qu'un objet <Blob> est créé, il peut être envoyé via MessagePort à plusieurs destinations sans transférer ni copier immédiatement les données. Les données contenues dans le Blob ne sont copiées que lorsque les méthodes arrayBuffer() ou text() sont appelées.

ESMCJS

import { Blob } from 'node:buffer'
import { setTimeout as delay } from 'node:timers/promises'

const blob = new Blob(['hello there'])

const mc1 = new MessageChannel()
const mc2 = new MessageChannel()

mc1.port1.onmessage = async ({ data }) => {
  console.log(await data.arrayBuffer())
  mc1.port1.close()
}

mc2.port1.onmessage = async ({ data }) => {
  await delay(1000)
  console.log(await data.arrayBuffer())
  mc2.port1.close()
}

mc1.port2.postMessage(blob)
mc2.port2.postMessage(blob)

// Le Blob est toujours utilisable après l'envoi.
blob.text().then(console.log)

const { Blob } = require('node:buffer')
const { setTimeout: delay } = require('node:timers/promises')

const blob = new Blob(['hello there'])

const mc1 = new MessageChannel()
const mc2 = new MessageChannel()

mc1.port1.onmessage = async ({ data }) => {
  console.log(await data.arrayBuffer())
  mc1.port1.close()
}

mc2.port1.onmessage = async ({ data }) => {
  await delay(1000)
  console.log(await data.arrayBuffer())
  mc2.port1.close()
}

mc1.port2.postMessage(blob)
mc2.port2.postMessage(blob)

// Le Blob est toujours utilisable après l'envoi.
blob.text().then(console.log)

Classe : `Buffer`

La classe Buffer est un type global pour gérer directement les données binaires. Elle peut être construite de plusieurs manières.

Méthode statique : `Buffer.alloc(size[, fill[, encoding]])`

[Historique]

Version	Modifications
v20.0.0	Lève ERR_INVALID_ARG_TYPE ou ERR_OUT_OF_RANGE au lieu de ERR_INVALID_ARG_VALUE pour les arguments d'entrée invalides.
v15.0.0	Lève ERR_INVALID_ARG_VALUE au lieu de ERR_INVALID_OPT_VALUE pour les arguments d'entrée invalides.
v10.0.0	La tentative de remplissage d'un tampon de longueur non nulle avec un tampon de longueur nulle déclenche une exception levée.
v10.0.0	La spécification d'une chaîne invalide pour `fill` déclenche une exception levée.
v8.9.3	La spécification d'une chaîne invalide pour `fill` entraîne désormais un tampon rempli de zéros.
v5.10.0	Ajouté dans : v5.10.0

size <entier> La longueur souhaitée du nouveau Buffer.
fill <chaîne de caractères> | <Buffer> | <Uint8Array> | <entier> Une valeur pour pré-remplir le nouveau Buffer. Valeur par défaut : 0.
encoding <chaîne de caractères> Si fill est une chaîne de caractères, il s'agit de son encodage. Valeur par défaut : 'utf8'.
Retourne : <Buffer>

Alloue un nouveau Buffer de size octets. Si fill est undefined, le Buffer sera rempli de zéros.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(5)

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

const { Buffer } = require('node:buffer')

const buf = Buffer.alloc(5)

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

Si size est supérieur à buffer.constants.MAX_LENGTH ou inférieur à 0, ERR_OUT_OF_RANGE est levée.

Si fill est spécifié, le Buffer alloué sera initialisé en appelant buf.fill(fill).

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(5, 'a')

console.log(buf)
// Affiche : <Buffer 61 61 61 61 61>

const { Buffer } = require('node:buffer')

const buf = Buffer.alloc(5, 'a')

console.log(buf)
// Affiche : <Buffer 61 61 61 61 61>

Si fill et encoding sont tous deux spécifiés, le Buffer alloué sera initialisé en appelant buf.fill(fill, encoding).

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64')

console.log(buf)
// Affiche : <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>

const { Buffer } = require('node:buffer')

const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64')

console.log(buf)
// Affiche : <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>

Appeler Buffer.alloc() peut être sensiblement plus lent que l'alternative Buffer.allocUnsafe(), mais garantit que le contenu de la nouvelle instance Buffer ne contiendra jamais de données sensibles provenant d'allocations précédentes, y compris des données qui pourraient ne pas avoir été allouées pour les Buffer.

Une erreur TypeError sera levée si size n'est pas un nombre.

Méthode statique : `Buffer.allocUnsafe(size)`

[Historique]

Version	Modifications
v20.0.0	Lève ERR_INVALID_ARG_TYPE ou ERR_OUT_OF_RANGE au lieu de ERR_INVALID_ARG_VALUE pour les arguments d'entrée invalides.
v15.0.0	Lève ERR_INVALID_ARG_VALUE au lieu de ERR_INVALID_OPT_VALUE pour les arguments d'entrée invalides.
v7.0.0	Passer une valeur `size` négative lèvera désormais une erreur.
v5.10.0	Ajouté dans : v5.10.0

size <entier> La longueur souhaitée du nouveau Buffer.
Retourne : <Buffer>

Alloue un nouveau Buffer de size octets. Si size est supérieur à buffer.constants.MAX_LENGTH ou inférieur à 0, ERR_OUT_OF_RANGE est levée.

La mémoire sous-jacente pour les instances Buffer créées de cette manière n'est pas initialisée. Le contenu du Buffer nouvellement créé est inconnu et peut contenir des données sensibles. Utilisez Buffer.alloc() à la place pour initialiser les instances Buffer avec des zéros.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(10)

console.log(buf)
// Affiche (le contenu peut varier) : <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0)

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

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(10)

console.log(buf)
// Affiche (le contenu peut varier) : <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0)

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

Une TypeError sera levée si size n'est pas un nombre.

Le module Buffer pré-alloue une instance interne Buffer de taille Buffer.poolSize qui est utilisée comme pool pour l'allocation rapide de nouvelles instances Buffer créées à l'aide de Buffer.allocUnsafe(), Buffer.from(array), Buffer.from(string), et Buffer.concat() uniquement lorsque size est inférieur à Buffer.poolSize \>\>\> 1 (partie entière de Buffer.poolSize divisée par deux).

L'utilisation de ce pool de mémoire interne pré-alloué est une différence clé entre l'appel de Buffer.alloc(size, fill) et Buffer.allocUnsafe(size).fill(fill). Plus précisément, Buffer.alloc(size, fill) n'utilisera jamais le pool interne Buffer, tandis que Buffer.allocUnsafe(size).fill(fill) utilisera le pool interne Buffer si size est inférieur ou égal à la moitié de Buffer.poolSize. La différence est subtile mais peut être importante lorsqu'une application nécessite les performances supplémentaires offertes par Buffer.allocUnsafe().

Méthode statique : `Buffer.allocUnsafeSlow(size)`

[Historique]

Version	Modifications
v20.0.0	Lance une exception ERR_INVALID_ARG_TYPE ou ERR_OUT_OF_RANGE au lieu de ERR_INVALID_ARG_VALUE pour les arguments d'entrée invalides.
v15.0.0	Lance une exception ERR_INVALID_ARG_VALUE au lieu de ERR_INVALID_OPT_VALUE pour les arguments d'entrée invalides.
v5.12.0	Ajouté dans : v5.12.0

size <entier> La longueur souhaitée du nouveau Buffer.
Retourne : <Buffer>

Alloue un nouveau Buffer de size octets. Si size est supérieur à buffer.constants.MAX_LENGTH ou inférieur à 0, une exception ERR_OUT_OF_RANGE est levée. Un Buffer de longueur nulle est créé si size est égal à 0.

La mémoire sous-jacente pour les instances Buffer créées de cette manière n’est pas initialisée. Le contenu du Buffer nouvellement créé est inconnu et peut contenir des données sensibles. Utilisez buf.fill(0) pour initialiser ces instances Buffer avec des zéros.

Lors de l’utilisation de Buffer.allocUnsafe() pour allouer de nouvelles instances Buffer, les allocations inférieures à Buffer.poolSize \>\>\> 1 (4 Ko lorsque la taille du pool par défaut est utilisée) sont extraites d’un seul Buffer pré-alloué. Cela permet aux applications d’éviter les frais généraux de collecte des ordures liés à la création de nombreuses instances Buffer allouées individuellement. Cette approche améliore à la fois les performances et l’utilisation de la mémoire en éliminant le besoin de suivre et de nettoyer autant d’objets ArrayBuffer individuels.

Cependant, dans le cas où un développeur peut avoir besoin de conserver un petit fragment de mémoire d’un pool pendant une durée indéterminée, il peut être approprié de créer une instance Buffer non mise en pool à l’aide de Buffer.allocUnsafeSlow() puis de copier les bits pertinents.

ESMCJS

import { Buffer } from 'node:buffer'

// Besoin de conserver quelques petits fragments de mémoire.
const store = []

socket.on('readable', () => {
  let data
  while (null !== (data = readable.read())) {
    // Allocation pour les données conservées.
    const sb = Buffer.allocUnsafeSlow(10)

    // Copie des données dans la nouvelle allocation.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

const { Buffer } = require('node:buffer')

// Besoin de conserver quelques petits fragments de mémoire.
const store = []

socket.on('readable', () => {
  let data
  while (null !== (data = readable.read())) {
    // Allocation pour les données conservées.
    const sb = Buffer.allocUnsafeSlow(10)

    // Copie des données dans la nouvelle allocation.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

Une exception TypeError sera levée si size n’est pas un nombre.

Méthode statique : `Buffer.byteLength(string[, encoding])`

[Historique]

Version	Modifications
v7.0.0	La transmission d'une entrée invalide lèvera désormais une erreur.
v5.10.0	Le paramètre `string` peut désormais être n'importe quel `TypedArray`, `DataView` ou `ArrayBuffer`.
v0.1.90	Ajouté dans : v0.1.90

string <string> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> Une valeur pour calculer la longueur de.
encoding <string> Si string est une chaîne de caractères, il s'agit de son encodage. Valeur par défaut : 'utf8'.
Retourne : <integer> Le nombre d'octets contenus dans string.

Retourne la longueur en octets d'une chaîne de caractères lorsqu'elle est encodée à l'aide de encoding. Ce n'est pas la même chose que String.prototype.length, qui ne tient pas compte de l'encodage utilisé pour convertir la chaîne de caractères en octets.

Pour 'base64', 'base64url' et 'hex', cette fonction suppose une entrée valide. Pour les chaînes de caractères contenant des données non encodées en base64/hex (par exemple, des espaces), la valeur de retour peut être supérieure à la longueur d'un Buffer créé à partir de la chaîne de caractères.

ESMCJS

import { Buffer } from 'node:buffer'

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

console.log(`${str}: ${str.length} caractères, ` + `${Buffer.byteLength(str, 'utf8')} octets`)
// Affiche : ½ + ¼ = ¾ : 9 caractères, 12 octets

const { Buffer } = require('node:buffer')

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

console.log(`${str}: ${str.length} caractères, ` + `${Buffer.byteLength(str, 'utf8')} octets`)
// Affiche : ½ + ¼ = ¾ : 9 caractères, 12 octets

Lorsque string est un Buffer/[DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView)/TypedArray/ArrayBuffer/SharedArrayBuffer, la longueur en octets telle que rapportée par .byteLength est retournée.

Méthode statique : `Buffer.compare(buf1, buf2)`

[Historique]

Version	Modifications
v8.0.0	Les arguments peuvent maintenant être des `Uint8Array`.
v0.11.13	Ajouté dans : v0.11.13

buf1 <Buffer> | <Uint8Array>
buf2 <Buffer> | <Uint8Array>
Retourne : <entier> Soit -1, 0 ou 1, selon le résultat de la comparaison. Voir buf.compare() pour plus de détails.

Compare buf1 à buf2, généralement pour trier les tableaux d’instances Buffer. Ceci est équivalent à appeler buf1.compare(buf2).

ESMCJS

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from('1234')
const buf2 = Buffer.from('0123')
const arr = [buf1, buf2]

console.log(arr.sort(Buffer.compare))
// Affiche : [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (Ce résultat est égal à : [buf2, buf1].)

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from('1234')
const buf2 = Buffer.from('0123')
const arr = [buf1, buf2]

console.log(arr.sort(Buffer.compare))
// Affiche : [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (Ce résultat est égal à : [buf2, buf1].)

Méthode statique : `Buffer.concat(list[, totalLength])`

[Historique]

Version	Modifications
v8.0.0	Les éléments de `list` peuvent maintenant être des `Uint8Array`.
v0.7.11	Ajouté dans : v0.7.11

list <Buffer[]> | <Uint8Array[]> Liste d’instances Buffer ou Uint8Array à concaténer.
totalLength <entier> Longueur totale des instances Buffer dans list lorsqu’elles sont concaténées.
Retourne : <Buffer>

Retourne un nouveau Buffer qui est le résultat de la concaténation de toutes les instances Buffer de la list.

Si la liste n’a aucun élément, ou si totalLength est 0, alors un nouveau Buffer de longueur nulle est retourné.

Si totalLength n’est pas fourni, il est calculé à partir des instances Buffer dans list en additionnant leurs longueurs.

Si totalLength est fourni, il est converti en un entier non signé. Si la longueur combinée des Buffer dans list dépasse totalLength, le résultat est tronqué à totalLength. Si la longueur combinée des Buffer dans list est inférieure à totalLength, l’espace restant est rempli de zéros.

ESMCJS

import { Buffer } from 'node:buffer'

// Créer un seul `Buffer` à partir d’une liste de trois instances `Buffer`.

const buf1 = Buffer.alloc(10)
const buf2 = Buffer.alloc(14)
const buf3 = Buffer.alloc(18)
const totalLength = buf1.length + buf2.length + buf3.length

console.log(totalLength)
// Affiche : 42

const bufA = Buffer.concat([buf1, buf2, buf3], totalLength)

console.log(bufA)
// Affiche : <Buffer 00 00 00 00 ...>
console.log(bufA.length)
// Affiche : 42

const { Buffer } = require('node:buffer')

// Créer un seul `Buffer` à partir d’une liste de trois instances `Buffer`.

const buf1 = Buffer.alloc(10)
const buf2 = Buffer.alloc(14)
const buf3 = Buffer.alloc(18)
const totalLength = buf1.length + buf2.length + buf3.length

console.log(totalLength)
// Affiche : 42

const bufA = Buffer.concat([buf1, buf2, buf3], totalLength)

console.log(bufA)
// Affiche : <Buffer 00 00 00 00 ...>
console.log(bufA.length)
// Affiche : 42

Buffer.concat() peut également utiliser le pool interne Buffer comme le fait Buffer.allocUnsafe().

Méthode statique : `Buffer.copyBytesFrom(view[, offset[, length]])`

Ajouté dans : v19.8.0, v18.16.0

view <TypedArray> Le <TypedArray> à copier.
offset <entier> Le décalage de départ dans view. Défaut : 0.
length <entier> Le nombre d’éléments de view à copier. Défaut : view.length - offset.
Retourne : <Buffer>

Copie la mémoire sous-jacente de view dans un nouveau Buffer.

const u16 = new Uint16Array([0, 0xffff])
const buf = Buffer.copyBytesFrom(u16, 1, 1)
u16[1] = 0
console.log(buf.length) // 2
console.log(buf[0]) // 255
console.log(buf[1]) // 255

Méthode statique : `Buffer.from(array)`

Ajouté dans : v5.10.0

array <entier[]>
Retourne : <Buffer>

Alloue un nouveau Buffer en utilisant un array d’octets dans la plage 0 – 255. Les entrées du tableau en dehors de cette plage seront tronquées pour s’y adapter.

ESMCJS

import { Buffer } from 'node:buffer'

// Crée un nouveau Buffer contenant les octets UTF-8 de la chaîne 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

const { Buffer } = require('node:buffer')

// Crée un nouveau Buffer contenant les octets UTF-8 de la chaîne 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

Si array est un objet semblable à un Array (c’est-à-dire un objet ayant une propriété length de type number), il est traité comme s’il s’agissait d’un tableau, sauf s’il s’agit d’un Buffer ou d’un Uint8Array. Cela signifie que toutes les autres variantes TypedArray sont traitées comme un Array. Pour créer un Buffer à partir des octets sous-jacents à un TypedArray, utilisez Buffer.copyBytesFrom().

Une erreur TypeError sera levée si array n’est pas un Array ou un autre type approprié pour les variantes Buffer.from().

Buffer.from(array) et Buffer.from(string) peuvent également utiliser le pool interne Buffer comme le fait Buffer.allocUnsafe().

Méthode statique : `Buffer.from(arrayBuffer[, byteOffset[, length]])`

Ajouté dans : v5.10.0

arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Un ArrayBuffer, SharedArrayBuffer, par exemple la propriété .buffer d'un TypedArray.
byteOffset <entier> Index du premier octet à exposer. Défaut : 0.
length <entier> Nombre d'octets à exposer. Défaut : arrayBuffer.byteLength - byteOffset.
Retourne : <Buffer>

Ceci crée une vue de l’ArrayBuffer sans copier la mémoire sous-jacente. Par exemple, lorsqu'une référence à la propriété .buffer d'une instance TypedArray est passée, le Buffer nouvellement créé partagera la même mémoire allouée que l’ArrayBuffer sous-jacent du TypedArray.

ESMCJS

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

arr[0] = 5000
arr[1] = 4000

// Partage la mémoire avec `arr`.
const buf = Buffer.from(arr.buffer)

console.log(buf)
// Affiche : <Buffer 88 13 a0 0f>

// Modifier le Uint16Array original modifie également le Buffer.
arr[1] = 6000

console.log(buf)
// Affiche : <Buffer 88 13 70 17>

const { Buffer } = require('node:buffer')

const arr = new Uint16Array(2)

arr[0] = 5000
arr[1] = 4000

// Partage la mémoire avec `arr`.
const buf = Buffer.from(arr.buffer)

console.log(buf)
// Affiche : <Buffer 88 13 a0 0f>

// Modifier le Uint16Array original modifie également le Buffer.
arr[1] = 6000

console.log(buf)
// Affiche : <Buffer 88 13 70 17>

Les arguments facultatifs byteOffset et length spécifient une plage de mémoire dans arrayBuffer qui sera partagée par Buffer.

ESMCJS

import { Buffer } from 'node:buffer'

const ab = new ArrayBuffer(10)
const buf = Buffer.from(ab, 0, 2)

console.log(buf.length)
// Affiche : 2

const { Buffer } = require('node:buffer')

const ab = new ArrayBuffer(10)
const buf = Buffer.from(ab, 0, 2)

console.log(buf.length)
// Affiche : 2

Une erreur TypeError sera levée si arrayBuffer n'est pas un ArrayBuffer ou un SharedArrayBuffer ou un autre type approprié pour les variantes Buffer.from().

Il est important de se rappeler qu'un ArrayBuffer sous-jacent peut couvrir une plage de mémoire qui dépasse les limites d'une vue TypedArray. Un nouveau Buffer créé à l'aide de la propriété buffer d'un TypedArray peut dépasser la plage du TypedArray :

ESMCJS

import { Buffer } from 'node:buffer'

const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]) // 4 éléments
const arrB = new Uint8Array(arrA.buffer, 1, 2) // 2 éléments
console.log(arrA.buffer === arrB.buffer) // true

const buf = Buffer.from(arrB.buffer)
console.log(buf)
// Affiche : <Buffer 63 64 65 66>

const { Buffer } = require('node:buffer')

const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]) // 4 éléments
const arrB = new Uint8Array(arrA.buffer, 1, 2) // 2 éléments
console.log(arrA.buffer === arrB.buffer) // true

const buf = Buffer.from(arrB.buffer)
console.log(buf)
// Affiche : <Buffer 63 64 65 66>

Méthode statique : `Buffer.from(buffer)`

Ajouté dans : v5.10.0

buffer <Buffer> | <Uint8Array> Un Buffer existant ou un Uint8Array à partir duquel copier les données.
Retourne : <Buffer>

Copie les données du buffer passé sur une nouvelle instance Buffer.

ESMCJS

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from('buffer')
const buf2 = Buffer.from(buf1)

buf1[0] = 0x61

console.log(buf1.toString())
// Affiche : auffer
console.log(buf2.toString())
// Affiche : buffer

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from('buffer')
const buf2 = Buffer.from(buf1)

buf1[0] = 0x61

console.log(buf1.toString())
// Affiche : auffer
console.log(buf2.toString())
// Affiche : buffer

Une erreur TypeError sera levée si buffer n'est pas un Buffer ou un autre type approprié pour les variantes Buffer.from().

Méthode statique : `Buffer.from(object[, offsetOrEncoding[, length]])`

Ajouté dans : v8.2.0

object <Object> Un objet supportant Symbol.toPrimitive ou valueOf().
offsetOrEncoding <integer> | <string> Un décalage d'octet ou un encodage.
length <integer> Une longueur.
Retourne : <Buffer>

Pour les objets dont la fonction valueOf() retourne une valeur non strictement égale à object, retourne Buffer.from(object.valueOf(), offsetOrEncoding, length).

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from(new String('this is a test'))
// Affiche : <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>

const { Buffer } = require('node:buffer')

const buf = Buffer.from(new String('this is a test'))
// Affiche : <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>

Pour les objets qui supportent Symbol.toPrimitive, retourne Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding).

ESMCJS

import { Buffer } from 'node:buffer'

class Foo {
  [Symbol.toPrimitive]() {
    return 'this is a test'
  }
}

const buf = Buffer.from(new Foo(), 'utf8')
// Affiche : <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>

const { Buffer } = require('node:buffer')

class Foo {
  [Symbol.toPrimitive]() {
    return 'this is a test'
  }
}

const buf = Buffer.from(new Foo(), 'utf8')
// Affiche : <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>

Une erreur TypeError sera levée si object ne possède pas les méthodes mentionnées ou n'est pas d'un autre type approprié pour les variantes Buffer.from().

Méthode statique : `Buffer.from(string[, encoding])`

Ajouté dans : v5.10.0

string <string> Une chaîne à encoder.
encoding <string> L'encodage de string. Défaut : 'utf8'.
Retourne : <Buffer>

Crée un nouveau Buffer contenant string. Le paramètre encoding identifie l'encodage des caractères à utiliser lors de la conversion de string en octets.

ESMCJS

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from('this is a tést')
const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex')

console.log(buf1.toString())
// Affiche : this is a tést
console.log(buf2.toString())
// Affiche : this is a tést
console.log(buf1.toString('latin1'))
// Affiche : this is a tÃ©st

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from('this is a tést')
const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex')

console.log(buf1.toString())
// Affiche : this is a tést
console.log(buf2.toString())
// Affiche : this is a tést
console.log(buf1.toString('latin1'))
// Affiche : this is a tÃ©st

Une erreur TypeError sera levée si string n'est pas une chaîne ou un autre type approprié pour les variantes de Buffer.from().

Buffer.from(string) peut également utiliser le pool interne Buffer comme le fait Buffer.allocUnsafe().

Méthode statique : `Buffer.isBuffer(obj)`

Ajouté dans : v0.1.101

obj <Object>
Retourne : <boolean>

Retourne true si obj est un Buffer, false sinon.

ESMCJS

import { Buffer } from 'node:buffer'

Buffer.isBuffer(Buffer.alloc(10)) // true
Buffer.isBuffer(Buffer.from('foo')) // true
Buffer.isBuffer('a string') // false
Buffer.isBuffer([]) // false
Buffer.isBuffer(new Uint8Array(1024)) // false

const { Buffer } = require('node:buffer')

Buffer.isBuffer(Buffer.alloc(10)) // true
Buffer.isBuffer(Buffer.from('foo')) // true
Buffer.isBuffer('a string') // false
Buffer.isBuffer([]) // false
Buffer.isBuffer(new Uint8Array(1024)) // false

Méthode statique : `Buffer.isEncoding(encoding)`

Ajouté dans : v0.9.1

encoding <string> Un nom d'encodage de caractères à vérifier.
Retourne : <boolean>

Retourne true si encoding est le nom d'un encodage de caractères pris en charge, ou false sinon.

ESMCJS

import { Buffer } from 'node:buffer'

console.log(Buffer.isEncoding('utf8'))
// Affiche : true

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

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

console.log(Buffer.isEncoding(''))
// Affiche : false

const { Buffer } = require('node:buffer')

console.log(Buffer.isEncoding('utf8'))
// Affiche : true

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

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

console.log(Buffer.isEncoding(''))
// Affiche : false

Propriété de classe : `Buffer.poolSize`

Ajouté dans : v0.11.3

<integer> Défaut : 8192

Il s'agit de la taille (en octets) des instances internes de Buffer pré-allouées utilisées pour la mise en commun. Cette valeur peut être modifiée.

`buf[index]`

index <integer>

L'opérateur d'index [index] peut être utilisé pour obtenir et définir l'octet à la position index dans buf. Les valeurs font référence à des octets individuels, donc la plage de valeurs légales est comprise entre 0x00 et 0xFF (hexadécimal) ou 0 et 255 (décimal).

Cet opérateur est hérité de Uint8Array, donc son comportement en cas d'accès en dehors des limites est le même que celui de Uint8Array. En d'autres termes, buf[index] retourne undefined lorsque index est négatif ou supérieur ou égal à buf.length, et buf[index] = value ne modifie pas le tampon si index est négatif ou \>= buf.length.

ESMCJS

import { Buffer } from 'node:buffer'

// Copier une chaîne ASCII dans un `Buffer` un octet à la fois.
// (Cela ne fonctionne que pour les chaînes ASCII uniquement. En général, il faut utiliser
// `Buffer.from()` pour effectuer cette conversion.)

const str = 'Node.js'
const buf = Buffer.allocUnsafe(str.length)

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

console.log(buf.toString('utf8'))
// Affiche : Node.js

const { Buffer } = require('node:buffer')

// Copier une chaîne ASCII dans un `Buffer` un octet à la fois.
// (Cela ne fonctionne que pour les chaînes ASCII uniquement. En général, il faut utiliser
// `Buffer.from()` pour effectuer cette conversion.)

const str = 'Node.js'
const buf = Buffer.allocUnsafe(str.length)

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

console.log(buf.toString('utf8'))
// Affiche : Node.js

`buf.buffer`

<ArrayBuffer> L'objet ArrayBuffer sous-jacent sur lequel cet objet Buffer est créé.

Cet ArrayBuffer n'est pas garanti de correspondre exactement au Buffer original. Voir les notes sur buf.byteOffset pour plus de détails.

ESMCJS

import { Buffer } from 'node:buffer'

const arrayBuffer = new ArrayBuffer(16)
const buffer = Buffer.from(arrayBuffer)

console.log(buffer.buffer === arrayBuffer)
// Affiche : true

const { Buffer } = require('node:buffer')

const arrayBuffer = new ArrayBuffer(16)
const buffer = Buffer.from(arrayBuffer)

console.log(buffer.buffer === arrayBuffer)
// Affiche : true

`buf.byteOffset`

<entier> Le byteOffset de l'objet ArrayBuffer sous-jacent du Buffer.

Lors de la définition de byteOffset dans Buffer.from(ArrayBuffer, byteOffset, length), ou parfois lors de l'allocation d'un Buffer plus petit que Buffer.poolSize, le buffer ne commence pas à partir d'un décalage nul sur le ArrayBuffer sous-jacent.

Cela peut causer des problèmes lors de l'accès direct au ArrayBuffer sous-jacent en utilisant buf.buffer, car d'autres parties du ArrayBuffer peuvent ne pas être liées à l'objet Buffer lui-même.

Un problème courant lors de la création d'un objet TypedArray qui partage sa mémoire avec un Buffer est que dans ce cas, il faut spécifier correctement le byteOffset :

ESMCJS

import { Buffer } from 'node:buffer'

// Créer un buffer plus petit que `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// Lors de la conversion du Buffer Node.js en Int8Array, utiliser le byteOffset
// pour ne faire référence qu'à la partie de `nodeBuffer.buffer` qui contient la mémoire
// pour `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

const { Buffer } = require('node:buffer')

// Créer un buffer plus petit que `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// Lors de la conversion du Buffer Node.js en Int8Array, utiliser le byteOffset
// pour ne faire référence qu'à la partie de `nodeBuffer.buffer` qui contient la mémoire
// pour `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

`buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])`

[Historique]

Version	Modifications
v8.0.0	Le paramètre `target` peut maintenant être un `Uint8Array`.
v5.11.0	Des paramètres supplémentaires pour spécifier les décalages sont maintenant pris en charge.
v0.11.13	Ajouté dans : v0.11.13

target <Buffer> | <Uint8Array> Un Buffer ou un Uint8Array avec lequel comparer buf.
targetStart <entier> Le décalage dans target auquel commencer la comparaison. Valeur par défaut : 0.
targetEnd <entier> Le décalage dans target auquel terminer la comparaison (non inclus). Valeur par défaut : target.length.
sourceStart <entier> Le décalage dans buf auquel commencer la comparaison. Valeur par défaut : 0.
sourceEnd <entier> Le décalage dans buf auquel terminer la comparaison (non inclus). Valeur par défaut : buf.length.
Retourne : <entier>

Compare buf avec target et retourne un nombre indiquant si buf vient avant, après ou est le même que target dans l'ordre de tri. La comparaison est basée sur la séquence réelle d'octets dans chaque Buffer.

0 est retourné si target est le même que buf
1 est retourné si target doit venir avant buf lorsqu'il est trié.
-1 est retourné si target doit venir après buf lorsqu'il est trié.

ESMCJS

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from('ABC')
const buf2 = Buffer.from('BCD')
const buf3 = Buffer.from('ABCD')

console.log(buf1.compare(buf1))
// Affiche : 0
console.log(buf1.compare(buf2))
// Affiche : -1
console.log(buf1.compare(buf3))
// Affiche : -1
console.log(buf2.compare(buf1))
// Affiche : 1
console.log(buf2.compare(buf3))
// Affiche : 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Affiche : [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (Ce résultat est égal à : [buf1, buf3, buf2].)

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from('ABC')
const buf2 = Buffer.from('BCD')
const buf3 = Buffer.from('ABCD')

console.log(buf1.compare(buf1))
// Affiche : 0
console.log(buf1.compare(buf2))
// Affiche : -1
console.log(buf1.compare(buf3))
// Affiche : -1
console.log(buf2.compare(buf1))
// Affiche : 1
console.log(buf2.compare(buf3))
// Affiche : 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Affiche : [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (Ce résultat est égal à : [buf1, buf3, buf2].)

Les arguments facultatifs targetStart, targetEnd, sourceStart et sourceEnd peuvent être utilisés pour limiter la comparaison à des plages spécifiques dans target et buf respectivement.

ESMCJS

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9])
const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4])

console.log(buf1.compare(buf2, 5, 9, 0, 4))
// Affiche : 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Affiche : -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Affiche : 1

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9])
const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4])

console.log(buf1.compare(buf2, 5, 9, 0, 4))
// Affiche : 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Affiche : -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Affiche : 1

ERR_OUT_OF_RANGE est levée si targetStart \< 0, sourceStart \< 0, targetEnd \> target.byteLength, ou sourceEnd \> source.byteLength.

`buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])`

Ajouté dans : v0.1.90

target <Buffer> | <Uint8Array> Un Buffer ou un Uint8Array dans lequel copier.
targetStart <integer> Le décalage dans target auquel commencer l'écriture. Par défaut : 0.
sourceStart <integer> Le décalage dans buf à partir duquel commencer la copie. Par défaut : 0.
sourceEnd <integer> Le décalage dans buf auquel arrêter la copie (non inclus). Par défaut : buf.length.
Retourne : <integer> Le nombre d'octets copiés.

Copie des données d'une région de buf vers une région de target, même si la région mémoire de target chevauche buf.

TypedArray.prototype.set() effectue la même opération et est disponible pour tous les TypedArrays, y compris les Buffer Node.js, bien qu'il prenne des arguments de fonction différents.

ESMCJS

import { Buffer } from 'node:buffer'

// Créer deux instances `Buffer`.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

for (let i = 0; i < 26; i++) {
  // 97 est la valeur ASCII décimale de 'a'.
  buf1[i] = i + 97
}

// Copier les octets 16 à 19 de `buf1` dans `buf2` en commençant à l'octet 8 de `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Ceci est équivalent à :
// buf2.set(buf1.subarray(16, 20), 8);

console.log(buf2.toString('ascii', 0, 25))
// Affiche : !!!!!!!!qrst!!!!!!!!!!!!!

const { Buffer } = require('node:buffer')

// Créer deux instances `Buffer`.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

for (let i = 0; i < 26; i++) {
  // 97 est la valeur ASCII décimale de 'a'.
  buf1[i] = i + 97
}

// Copier les octets 16 à 19 de `buf1` dans `buf2` en commençant à l'octet 8 de `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Ceci est équivalent à :
// buf2.set(buf1.subarray(16, 20), 8);

console.log(buf2.toString('ascii', 0, 25))
// Affiche : !!!!!!!!qrst!!!!!!!!!!!!!

ESMCJS

import { Buffer } from 'node:buffer'

// Créer un `Buffer` et copier les données d'une région vers une région qui se chevauche
// dans le même `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 est la valeur ASCII décimale de 'a'.
  buf[i] = i + 97
}

buf.copy(buf, 0, 4, 10)

console.log(buf.toString())
// Affiche : efghijghijklmnopqrstuvwxyz

const { Buffer } = require('node:buffer')

// Créer un `Buffer` et copier les données d'une région vers une région qui se chevauche
// dans le même `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 est la valeur ASCII décimale de 'a'.
  buf[i] = i + 97
}

buf.copy(buf, 0, 4, 10)

console.log(buf.toString())
// Affiche : efghijghijklmnopqrstuvwxyz

`buf.entries()`

Ajouté dans : v1.1.0

Retourne : <Iterator>

Crée et retourne un itérateur de paires [index, byte] à partir du contenu de buf.

ESMCJS

import { Buffer } from 'node:buffer'

// Affiche le contenu entier d'un `Buffer`.

const buf = Buffer.from('buffer')

for (const pair of buf.entries()) {
  console.log(pair)
}
// Affiche :
//   [0, 98]
//   [1, 117]
//   [2, 102]
//   [3, 102]
//   [4, 101]
//   [5, 114]

const { Buffer } = require('node:buffer')

// Affiche le contenu entier d'un `Buffer`.

const buf = Buffer.from('buffer')

for (const pair of buf.entries()) {
  console.log(pair)
}
// Affiche :
//   [0, 98]
//   [1, 117]
//   [2, 102]
//   [3, 102]
//   [4, 101]
//   [5, 114]

`buf.equals(otherBuffer)`

[Historique]

Version	Modifications
v8.0.0	Les arguments peuvent maintenant être des `Uint8Array`.
v0.11.13	Ajouté dans : v0.11.13

otherBuffer <Buffer> | <Uint8Array> Un Buffer ou un Uint8Array avec lequel comparer buf.
Retourne : <boolean>

Retourne true si buf et otherBuffer ont exactement les mêmes octets, false sinon. Équivalent à buf.compare(otherBuffer) === 0.

ESMCJS

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from('ABC')
const buf2 = Buffer.from('414243', 'hex')
const buf3 = Buffer.from('ABCD')

console.log(buf1.equals(buf2))
// Affiche : true
console.log(buf1.equals(buf3))
// Affiche : false

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from('ABC')
const buf2 = Buffer.from('414243', 'hex')
const buf3 = Buffer.from('ABCD')

console.log(buf1.equals(buf2))
// Affiche : true
console.log(buf1.equals(buf3))
// Affiche : false

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

[Historique]

Version	Modifications
v11.0.0	Lance `ERR_OUT_OF_RANGE` au lieu de `ERR_INDEX_OUT_OF_RANGE`.
v10.0.0	Les valeurs `end` négatives lancent une erreur `ERR_INDEX_OUT_OF_RANGE`.
v10.0.0	La tentative de remplissage d'un tampon de longueur non nulle avec un tampon de longueur nulle déclenche une exception.
v10.0.0	La spécification d'une chaîne invalide pour `value` déclenche une exception.
v5.7.0	Le paramètre `encoding` est désormais pris en charge.
v0.5.0	Ajouté dans : v0.5.0

value <string> | <Buffer> | <Uint8Array> | <integer> La valeur avec laquelle remplir buf. Une valeur vide (chaîne, Uint8Array, Buffer) est convertie en 0.
offset <integer> Nombre d'octets à ignorer avant de commencer à remplir buf. Par défaut : 0.
end <integer> Où arrêter de remplir buf (non inclus). Par défaut : buf.length.
encoding <string> L'encodage pour value si value est une chaîne. Par défaut : 'utf8'.
Retourne : <Buffer> Une référence à buf.

Remplit buf avec la valeur value spécifiée. Si offset et end ne sont pas donnés, buf entier sera rempli :

ESMCJS

import { Buffer } from 'node:buffer'

// Remplir un `Buffer` avec le caractère ASCII 'h'.

const b = Buffer.allocUnsafe(50).fill('h')

console.log(b.toString())
// Affiche : hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Remplir un tampon avec une chaîne vide
const c = Buffer.allocUnsafe(5).fill('')

console.log(c.fill(''))
// Affiche : <Buffer 00 00 00 00 00>

const { Buffer } = require('node:buffer')

// Remplir un `Buffer` avec le caractère ASCII 'h'.

const b = Buffer.allocUnsafe(50).fill('h')

console.log(b.toString())
// Affiche : hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Remplir un tampon avec une chaîne vide
const c = Buffer.allocUnsafe(5).fill('')

console.log(c.fill(''))
// Affiche : <Buffer 00 00 00 00 00>

value est converti en une valeur uint32 s'il ne s'agit pas d'une chaîne, d'un Buffer ou d'un entier. Si l'entier résultant est supérieur à 255 (décimal), buf sera rempli avec value & 255.

Si la dernière écriture d'une opération fill() tombe sur un caractère multi-octets, seuls les octets de ce caractère qui tiennent dans buf sont écrits :

ESMCJS

import { Buffer } from 'node:buffer'

// Remplir un `Buffer` avec un caractère qui occupe deux octets en UTF-8.

console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// Affiche : <Buffer c8 a2 c8 a2 c8>

const { Buffer } = require('node:buffer')

// Remplir un `Buffer` avec un caractère qui occupe deux octets en UTF-8.

console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// Affiche : <Buffer c8 a2 c8 a2 c8>

Si value contient des caractères invalides, il est tronqué ; s'il ne reste aucune donnée de remplissage valide, une exception est levée :

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(5)

console.log(buf.fill('a'))
// Affiche : <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Affiche : <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// Lève une exception.

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(5)

console.log(buf.fill('a'))
// Affiche : <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Affiche : <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// Lève une exception.

`buf.includes(value[, byteOffset][, encoding])`

Ajouté dans : v5.3.0

value <string> | <Buffer> | <Uint8Array> | <integer> Ce que rechercher.
byteOffset <integer> Où commencer la recherche dans buf. Si négatif, le décalage est calculé à partir de la fin de buf. Défaut : 0.
encoding <string> Si value est une chaîne, il s’agit de son encodage. Défaut : 'utf8'.
Retourne : <boolean> true si value a été trouvé dans buf, false sinon.

Équivalent à buf.indexOf() !== -1.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('this is a buffer')

console.log(buf.includes('this'))
// Affiche : true
console.log(buf.includes('is'))
// Affiche : true
console.log(buf.includes(Buffer.from('a buffer')))
// Affiche : true
console.log(buf.includes(97))
// Affiche : true (97 est la valeur ASCII décimale de 'a')
console.log(buf.includes(Buffer.from('a buffer example')))
// Affiche : false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Affiche : true
console.log(buf.includes('this', 4))
// Affiche : false

const { Buffer } = require('node:buffer')

const buf = Buffer.from('this is a buffer')

console.log(buf.includes('this'))
// Affiche : true
console.log(buf.includes('is'))
// Affiche : true
console.log(buf.includes(Buffer.from('a buffer')))
// Affiche : true
console.log(buf.includes(97))
// Affiche : true (97 est la valeur ASCII décimale de 'a')
console.log(buf.includes(Buffer.from('a buffer example')))
// Affiche : false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Affiche : true
console.log(buf.includes('this', 4))
// Affiche : false

`buf.indexOf(value[, byteOffset][, encoding])`

[Historique]

Version	Modifications
v8.0.0	`value` peut maintenant être un `Uint8Array`.
v5.7.0, v4.4.0	Lorsque `encoding` est passé, le paramètre `byteOffset` n'est plus requis.
v1.5.0	Ajouté dans : v1.5.0

value <string> | <Buffer> | <Uint8Array> | <integer> Ce que rechercher.
byteOffset <integer> Où commencer la recherche dans buf. Si négatif, le décalage est calculé à partir de la fin de buf. Défaut : 0.
encoding <string> Si value est une chaîne, il s'agit de l'encodage utilisé pour déterminer la représentation binaire de la chaîne qui sera recherchée dans buf. Défaut : 'utf8'.
Retourne : <integer> L'index de la première occurrence de value dans buf, ou -1 si buf ne contient pas value.

Si value est :

une chaîne, value est interprétée selon l'encodage de caractères dans encoding.
un Buffer ou Uint8Array, value sera utilisé dans son intégralité. Pour comparer un Buffer partiel, utilisez buf.subarray.
un nombre, value sera interprété comme une valeur entière non signée sur 8 bits entre 0 et 255.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('this is a buffer')

console.log(buf.indexOf('this'))
// Affiche : 0
console.log(buf.indexOf('is'))
// Affiche : 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Affiche : 8
console.log(buf.indexOf(97))
// Affiche : 8 (97 est la valeur ASCII décimale de 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Affiche : -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Affiche : 8

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// Affiche : 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// Affiche : 6

const { Buffer } = require('node:buffer')

const buf = Buffer.from('this is a buffer')

console.log(buf.indexOf('this'))
// Affiche : 0
console.log(buf.indexOf('is'))
// Affiche : 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Affiche : 8
console.log(buf.indexOf(97))
// Affiche : 8 (97 est la valeur ASCII décimale de 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Affiche : -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Affiche : 8

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// Affiche : 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// Affiche : 6

Si value n'est pas une chaîne, un nombre ou un Buffer, cette méthode lèvera une erreur TypeError. Si value est un nombre, il sera converti en une valeur d'octet valide, un entier compris entre 0 et 255.

Si byteOffset n'est pas un nombre, il sera converti en nombre. Si le résultat de la conversion est NaN ou 0, la totalité du buffer sera recherchée. Ce comportement correspond à String.prototype.indexOf().

ESMCJS

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Passage d'une valeur qui est un nombre, mais pas un octet valide.
// Affiche : 2, équivalent à la recherche de 99 ou 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Passage d'un byteOffset qui se convertit en NaN ou 0.
// Affiche : 1, recherche du buffer entier.
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))

const { Buffer } = require('node:buffer')

const b = Buffer.from('abcdef')

// Passage d'une valeur qui est un nombre, mais pas un octet valide.
// Affiche : 2, équivalent à la recherche de 99 ou 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Passage d'un byteOffset qui se convertit en NaN ou 0.
// Affiche : 1, recherche du buffer entier.
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))

Si value est une chaîne vide ou un Buffer vide et que byteOffset est inférieur à buf.length, byteOffset sera retourné. Si value est vide et que byteOffset est au moins égal à buf.length, buf.length sera retourné.

`buf.keys()`

Ajouté dans : v1.1.0

Retourne : <Itérateur>

Crée et retourne un itérateur des clés (index) de buf.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

for (const key of buf.keys()) {
  console.log(key)
}
// Affiche :
//   0
//   1
//   2
//   3
//   4
//   5

const { Buffer } = require('node:buffer')

const buf = Buffer.from('buffer')

for (const key of buf.keys()) {
  console.log(key)
}
// Affiche :
//   0
//   1
//   2
//   3
//   4
//   5

`buf.lastIndexOf(value[, byteOffset][, encoding])`

[Historique]

Version	Modifications
v8.0.0	La valeur `value` peut maintenant être un `Uint8Array`.
v6.0.0	Ajouté dans : v6.0.0

value <chaîne de caractères> | <Buffer> | <Uint8Array> | <entier> Ce que rechercher.
byteOffset <entier> Où commencer la recherche dans buf. Si négatif, le décalage est calculé à partir de la fin de buf. Par défaut : buf.length - 1.
encoding <chaîne de caractères> Si value est une chaîne de caractères, il s'agit de l'encodage utilisé pour déterminer la représentation binaire de la chaîne qui sera recherchée dans buf. Par défaut : 'utf8'.
Retourne : <entier> L'index de la dernière occurrence de value dans buf, ou -1 si buf ne contient pas value.

Identique à buf.indexOf(), sauf que la dernière occurrence de value est trouvée plutôt que la première occurrence.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('this buffer is a buffer')

console.log(buf.lastIndexOf('this'))
// Affiche : 0
console.log(buf.lastIndexOf('buffer'))
// Affiche : 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// Affiche : 17
console.log(buf.lastIndexOf(97))
// Affiche : 15 (97 est la valeur ASCII décimale de 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// Affiche : -1
console.log(buf.lastIndexOf('buffer', 5))
// Affiche : 5
console.log(buf.lastIndexOf('buffer', 4))
// Affiche : -1

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'))
// Affiche : 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'))
// Affiche : 4

const { Buffer } = require('node:buffer')

const buf = Buffer.from('this buffer is a buffer')

console.log(buf.lastIndexOf('this'))
// Affiche : 0
console.log(buf.lastIndexOf('buffer'))
// Affiche : 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// Affiche : 17
console.log(buf.lastIndexOf(97))
// Affiche : 15 (97 est la valeur ASCII décimale de 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// Affiche : -1
console.log(buf.lastIndexOf('buffer', 5))
// Affiche : 5
console.log(buf.lastIndexOf('buffer', 4))
// Affiche : -1

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'))
// Affiche : 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'))
// Affiche : 4

Si value n'est pas une chaîne de caractères, un nombre ou un Buffer, cette méthode lèvera une erreur TypeError. Si value est un nombre, il sera converti en une valeur d'octet valide, un entier compris entre 0 et 255.

Si byteOffset n'est pas un nombre, il sera converti en un nombre. Tous les arguments qui se convertissent en NaN, comme {} ou undefined, rechercheront dans la totalité du buffer. Ce comportement correspond à String.prototype.lastIndexOf().

ESMCJS

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Passage d'une valeur qui est un nombre, mais pas un octet valide.
// Affiche : 2, équivalent à la recherche de 99 ou 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Passage d'un byteOffset qui se convertit en NaN.
// Affiche : 1, recherche dans tout le buffer.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Passage d'un byteOffset qui se convertit en 0.
// Affiche : -1, équivalent au passage de 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

const { Buffer } = require('node:buffer')

const b = Buffer.from('abcdef')

// Passage d'une valeur qui est un nombre, mais pas un octet valide.
// Affiche : 2, équivalent à la recherche de 99 ou 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Passage d'un byteOffset qui se convertit en NaN.
// Affiche : 1, recherche dans tout le buffer.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Passage d'un byteOffset qui se convertit en 0.
// Affiche : -1, équivalent au passage de 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

Si value est une chaîne de caractères vide ou un Buffer vide, byteOffset sera retourné.

`buf.length`

Ajouté dans : v0.1.90

<entier>

Retourne le nombre d'octets dans buf.

ESMCJS

import { Buffer } from 'node:buffer'

// Créer un `Buffer` et écrire une chaîne plus courte en utilisant UTF-8.

const buf = Buffer.alloc(1234)

console.log(buf.length)
// Affiche : 1234

buf.write('some string', 0, 'utf8')

console.log(buf.length)
// Affiche : 1234

const { Buffer } = require('node:buffer')

// Créer un `Buffer` et écrire une chaîne plus courte en utilisant UTF-8.

const buf = Buffer.alloc(1234)

console.log(buf.length)
// Affiche : 1234

buf.write('some string', 0, 'utf8')

console.log(buf.length)
// Affiche : 1234

`buf.parent`

Déprécié depuis : v8.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié : Utilisez buf.buffer à la place.

La propriété buf.parent est un alias déprécié pour buf.buffer.

`buf.readBigInt64BE([offset])`

Ajouté dans : v12.0.0, v10.20.0

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire : 0 \<= offset \<= buf.length - 8. Par défaut : 0.
Retourne : <bigint>

Lit un entier signé de 64 bits big-endian depuis buf à l'offset spécifié.

Les entiers lus depuis un Buffer sont interprétés comme des valeurs signées en complément à deux.

`buf.readBigInt64LE([offset])`

Ajouté dans : v12.0.0, v10.20.0

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire : 0 \<= offset \<= buf.length - 8. Par défaut : 0.
Retourne : <bigint>

Lit un entier signé de 64 bits little-endian depuis buf à l'offset spécifié.

Les entiers lus depuis un Buffer sont interprétés comme des valeurs signées en complément à deux.

`buf.readBigUInt64BE([offset])`

[Historique]

Version	Modifications
v14.10.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.readBigUint64BE()`.
v12.0.0, v10.20.0	Ajoutée dans : v12.0.0, v10.20.0

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire : 0 \<= offset \<= buf.length - 8. Valeur par défaut : 0.
Retourne : <bigint>

Lit un entier non signé de 64 bits en big-endian depuis buf à l'offset spécifié.

Cette fonction est également disponible sous l'alias readBigUint64BE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])

console.log(buf.readBigUInt64BE(0))
// Affiche : 4294967295n

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])

console.log(buf.readBigUInt64BE(0))
// Affiche : 4294967295n

`buf.readBigUInt64LE([offset])`

[Historique]

Version	Modifications
v14.10.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.readBigUint64LE()`.
v12.0.0, v10.20.0	Ajoutée dans : v12.0.0, v10.20.0

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire : 0 \<= offset \<= buf.length - 8. Valeur par défaut : 0.
Retourne : <bigint>

Lit un entier non signé de 64 bits en little-endian depuis buf à l'offset spécifié.

Cette fonction est également disponible sous l'alias readBigUint64LE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])

console.log(buf.readBigUInt64LE(0))
// Affiche : 18446744069414584320n

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])

console.log(buf.readBigUInt64LE(0))
// Affiche : 18446744069414584320n

`buf.readDoubleBE([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.11.15	Ajouté dans la version : v0.11.15

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 8. Défaut : 0.
Retourne : <nombre>

Lit un double 64 bits, big-endian, depuis buf à l'offset spécifié.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])

console.log(buf.readDoubleBE(0))
// Affiche : 8.20788039913184e-304

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])

console.log(buf.readDoubleBE(0))
// Affiche : 8.20788039913184e-304

`buf.readDoubleLE([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.11.15	Ajouté dans la version : v0.11.15

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 8. Défaut : 0.
Retourne : <nombre>

Lit un double 64 bits, little-endian, depuis buf à l'offset spécifié.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])

console.log(buf.readDoubleLE(0))
// Affiche : 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Lance ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])

console.log(buf.readDoubleLE(0))
// Affiche : 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Lance ERR_OUT_OF_RANGE.

`buf.readFloatBE([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.11.15	Ajouté dans la version : v0.11.15

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Valeur par défaut : 0.
Retourne : <nombre>

Lit un flottant 32 bits, big-endian, depuis buf à l'offset spécifié.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, 2, 3, 4])

console.log(buf.readFloatBE(0))
// Affiche : 2.387939260590663e-38

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, 2, 3, 4])

console.log(buf.readFloatBE(0))
// Affiche : 2.387939260590663e-38

`buf.readFloatLE([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.11.15	Ajouté dans la version : v0.11.15

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Valeur par défaut : 0.
Retourne : <nombre>

Lit un flottant 32 bits, little-endian, depuis buf à l'offset spécifié.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, 2, 3, 4])

console.log(buf.readFloatLE(0))
// Affiche : 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Lance ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, 2, 3, 4])

console.log(buf.readFloatLE(0))
// Affiche : 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Lance ERR_OUT_OF_RANGE.

`buf.readInt8([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.0	Ajouté dans : v0.5.0

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 1. Défaut : 0.
Retourne : <entier>

Lit un entier signé sur 8 bits depuis buf à l'offset spécifié.

Les entiers lus depuis un Buffer sont interprétés comme des valeurs signées en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([-1, 5])

console.log(buf.readInt8(0))
// Affiche : -1
console.log(buf.readInt8(1))
// Affiche : 5
console.log(buf.readInt8(2))
// Lance ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([-1, 5])

console.log(buf.readInt8(0))
// Affiche : -1
console.log(buf.readInt8(1))
// Affiche : 5
console.log(buf.readInt8(2))
// Lance ERR_OUT_OF_RANGE.

`buf.readInt16BE([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajouté dans : v0.5.5

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 2. Défaut : 0.
Retourne : <entier>

Lit un entier signé sur 16 bits, big-endian, depuis buf à l'offset spécifié.

Les entiers lus depuis un Buffer sont interprétés comme des valeurs signées en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0, 5])

console.log(buf.readInt16BE(0))
// Affiche : 5

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0, 5])

console.log(buf.readInt16BE(0))
// Affiche : 5

`buf.readInt16LE([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajouté dans la version : v0.5.5

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 2. Par défaut : 0.
Retourne : <entier>

Lit un entier signé de 16 bits, en little-endian, depuis buf à l'offset spécifié.

Les entiers lus depuis un Buffer sont interprétés comme des valeurs signées en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0, 5])

console.log(buf.readInt16LE(0))
// Affiche : 1280
console.log(buf.readInt16LE(1))
// Lève ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0, 5])

console.log(buf.readInt16LE(0))
// Affiche : 1280
console.log(buf.readInt16LE(1))
// Lève ERR_OUT_OF_RANGE.

`buf.readInt32BE([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajouté dans la version : v0.5.5

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Par défaut : 0.
Retourne : <entier>

Lit un entier signé de 32 bits, en big-endian, depuis buf à l'offset spécifié.

Les entiers lus depuis un Buffer sont interprétés comme des valeurs signées en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0, 0, 0, 5])

console.log(buf.readInt32BE(0))
// Affiche : 5

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0, 0, 0, 5])

console.log(buf.readInt32BE(0))
// Affiche : 5

`buf.readInt32LE([offset])`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajouté dans : v0.5.5

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Défaut : 0.
Retourne : <entier>

Lit un entier signé de 32 bits, en little-endian, depuis buf à l'offset spécifié.

Les entiers lus depuis un Buffer sont interprétés comme des valeurs signées en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0, 0, 0, 5])

console.log(buf.readInt32LE(0))
// Affiche : 83886080
console.log(buf.readInt32LE(1))
// Lance ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0, 0, 0, 5])

console.log(buf.readInt32LE(0))
// Affiche : 83886080
console.log(buf.readInt32LE(1))
// Lance ERR_OUT_OF_RANGE.

`buf.readIntBE(offset, byteLength)`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset et de `byteLength` en `uint32`.
v0.11.15	Ajouté dans : v0.11.15

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - byteLength.
byteLength <entier> Nombre d'octets à lire. Doit satisfaire 0 \< byteLength \<= 6.
Retourne : <entier>

Lit byteLength octets depuis buf à l'offset spécifié et interprète le résultat comme une valeur signée en complément à deux, big-endian, supportant jusqu'à 48 bits de précision.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readIntBE(0, 6).toString(16))
// Affiche : 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// Lance ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Lance ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readIntBE(0, 6).toString(16))
// Affiche : 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// Lance ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Lance ERR_OUT_OF_RANGE.

`buf.readIntLE(offset, byteLength)`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset et de `byteLength` en `uint32`.
v0.11.15	Ajouté dans : v0.11.15

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - byteLength.
byteLength <entier> Nombre d'octets à lire. Doit satisfaire 0 \< byteLength \<= 6.
Retourne : <entier>

Lit byteLength octets depuis buf à l'offset spécifié et interprète le résultat comme une valeur signée en complément à deux, petit-boutiste, supportant jusqu'à 48 bits de précision.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readIntLE(0, 6).toString(16))
// Affiche : -546f87a9cbee

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readIntLE(0, 6).toString(16))
// Affiche : -546f87a9cbee

`buf.readUInt8([offset])`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est aussi disponible sous le nom `buf.readUint8()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.0	Ajouté dans : v0.5.0

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 1. Défaut : 0.
Retourne : <entier>

Lit un entier non signé de 8 bits depuis buf à l'offset spécifié.

Cette fonction est aussi disponible sous l'alias readUint8.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, -2])

console.log(buf.readUInt8(0))
// Affiche : 1
console.log(buf.readUInt8(1))
// Affiche : 254
console.log(buf.readUInt8(2))
// Lance ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, -2])

console.log(buf.readUInt8(0))
// Affiche : 1
console.log(buf.readUInt8(1))
// Affiche : 254
console.log(buf.readUInt8(2))
// Lance ERR_OUT_OF_RANGE.

`buf.readUInt16BE([offset])`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.readUint16BE()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 2. Défaut : 0.
Retourne : <entier>

Lit un entier non signé de 16 bits, big-endian, depuis buf à l'offset spécifié.

Cette fonction est également disponible sous l'alias readUint16BE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56])

console.log(buf.readUInt16BE(0).toString(16))
// Affiche : 1234
console.log(buf.readUInt16BE(1).toString(16))
// Affiche : 3456

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56])

console.log(buf.readUInt16BE(0).toString(16))
// Affiche : 1234
console.log(buf.readUInt16BE(1).toString(16))
// Affiche : 3456

`buf.readUInt16LE([offset])`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.readUint16LE()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 2. Défaut : 0.
Retourne : <entier>

Lit un entier non signé de 16 bits, little-endian, depuis buf à l'offset spécifié.

Cette fonction est également disponible sous l'alias readUint16LE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56])

console.log(buf.readUInt16LE(0).toString(16))
// Affiche : 3412
console.log(buf.readUInt16LE(1).toString(16))
// Affiche : 5634
console.log(buf.readUInt16LE(2).toString(16))
// Lance ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56])

console.log(buf.readUInt16LE(0).toString(16))
// Affiche : 3412
console.log(buf.readUInt16LE(1).toString(16))
// Affiche : 5634
console.log(buf.readUInt16LE(2).toString(16))
// Lance ERR_OUT_OF_RANGE.

`buf.readUInt32BE([offset])`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.readUint32BE()`.
v10.0.0	Suppression de `noAssert` et plus de coercition implicite de l'offset en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Valeur par défaut : 0.
Retourne : <entier>

Lit un entier non signé de 32 bits big-endian à partir de buf à l'offset spécifié.

Cette fonction est également disponible sous l'alias readUint32BE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])

console.log(buf.readUInt32BE(0).toString(16))
// Affiche : 12345678

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])

console.log(buf.readUInt32BE(0).toString(16))
// Affiche : 12345678

`buf.readUInt32LE([offset])`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.readUint32LE()`.
v10.0.0	Suppression de `noAssert` et plus de coercition implicite de l'offset en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Valeur par défaut : 0.
Retourne : <entier>

Lit un entier non signé de 32 bits little-endian à partir de buf à l'offset spécifié.

Cette fonction est également disponible sous l'alias readUint32LE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])

console.log(buf.readUInt32LE(0).toString(16))
// Affiche : 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Lance ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])

console.log(buf.readUInt32LE(0).toString(16))
// Affiche : 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Lance ERR_OUT_OF_RANGE.

`buf.readUIntBE(offset, byteLength)`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.readUintBE()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset et de `byteLength` en `uint32`.
v0.11.15	Ajoutée dans la version : v0.11.15

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - byteLength.
byteLength <entier> Nombre d'octets à lire. Doit satisfaire 0 \< byteLength \<= 6.
Retourne : <entier>

Lit byteLength octets depuis buf à l'offset spécifié et interprète le résultat comme un entier non signé big-endian supportant jusqu'à 48 bits de précision.

Cette fonction est également disponible sous l'alias readUintBE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readUIntBE(0, 6).toString(16))
// Affiche : 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// Lève ERR_OUT_OF_RANGE.

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readUIntBE(0, 6).toString(16))
// Affiche : 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// Lève ERR_OUT_OF_RANGE.

`buf.readUIntLE(offset, byteLength)`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.readUintLE()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset et de `byteLength` en `uint32`.
v0.11.15	Ajoutée dans la version : v0.11.15

offset <entier> Nombre d'octets à ignorer avant de commencer la lecture. Doit satisfaire 0 \<= offset \<= buf.length - byteLength.
byteLength <entier> Nombre d'octets à lire. Doit satisfaire 0 \< byteLength \<= 6.
Retourne : <entier>

Lit byteLength octets depuis buf à l'offset spécifié et interprète le résultat comme un entier non signé little-endian supportant jusqu'à 48 bits de précision.

Cette fonction est également disponible sous l'alias readUintLE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readUIntLE(0, 6).toString(16))
// Affiche : ab9078563412

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readUIntLE(0, 6).toString(16))
// Affiche : ab9078563412

`buf.subarray([start[, end]])`

Ajouté dans : v3.0.0

start <entier> Où commencera le nouveau Buffer. Par défaut : 0.
end <entier> Où se terminera le nouveau Buffer (non inclus). Par défaut : buf.length.
Retourne : <Buffer>

Retourne un nouveau Buffer qui référence la même mémoire que l'original, mais décalé et tronqué par les index start et end.

Spécifier end supérieur à buf.length retournera le même résultat que celui de end égal à buf.length.

Cette méthode est héritée de TypedArray.prototype.subarray().

Modifier la nouvelle tranche Buffer modifiera la mémoire du Buffer original car la mémoire allouée des deux objets se chevauche.

ESMCJS

import { Buffer } from 'node:buffer'

// Créer un `Buffer` avec l'alphabet ASCII, prendre une tranche et modifier un octet
// du `Buffer` original.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 est la valeur ASCII décimale de 'a'.
  buf1[i] = i + 97
}

const buf2 = buf1.subarray(0, 3)

console.log(buf2.toString('ascii', 0, buf2.length))
// Affiche : abc

buf1[0] = 33

console.log(buf2.toString('ascii', 0, buf2.length))
// Affiche : !bc

const { Buffer } = require('node:buffer')

// Créer un `Buffer` avec l'alphabet ASCII, prendre une tranche et modifier un octet
// du `Buffer` original.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 est la valeur ASCII décimale de 'a'.
  buf1[i] = i + 97
}

const buf2 = buf1.subarray(0, 3)

console.log(buf2.toString('ascii', 0, buf2.length))
// Affiche : abc

buf1[0] = 33

console.log(buf2.toString('ascii', 0, buf2.length))
// Affiche : !bc

La spécification d'index négatifs fait que la tranche est générée par rapport à la fin de buf plutôt qu'au début.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

console.log(buf.subarray(-6, -1).toString())
// Affiche : buffe
// (Équivalent à buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString())
// Affiche : buff
// (Équivalent à buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString())
// Affiche : uff
// (Équivalent à buf.subarray(1, 4).)

const { Buffer } = require('node:buffer')

const buf = Buffer.from('buffer')

console.log(buf.subarray(-6, -1).toString())
// Affiche : buffe
// (Équivalent à buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString())
// Affiche : buff
// (Équivalent à buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString())
// Affiche : uff
// (Équivalent à buf.subarray(1, 4).)

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

[Historique]

Version	Modifications
v17.5.0, v16.15.0	La méthode buf.slice() est obsolète.
v7.0.0	Tous les décalages sont désormais convertis en entiers avant tout calcul.
v7.1.0, v6.9.2	La conversion des décalages en entiers gère désormais correctement les valeurs en dehors de la plage des entiers 32 bits.
v0.3.0	Ajouté dans : v0.3.0

start <entier> Où le nouveau Buffer commencera. Défaut : 0.
end <entier> Où le nouveau Buffer se terminera (non inclus). Défaut : buf.length.
Retourne : <Buffer>

[Stable : 0 - Obsolete]

Stable : 0 Stabilité : 0 - Obsolete : Utilisez buf.subarray à la place.

Retourne un nouveau Buffer qui référence la même mémoire que l'original, mais décalé et recadré par les index start et end.

Cette méthode n'est pas compatible avec Uint8Array.prototype.slice(), qui est une superclasse de Buffer. Pour copier la tranche, utilisez Uint8Array.prototype.slice().

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

const copiedBuf = Uint8Array.prototype.slice.call(buf)
copiedBuf[0]++
console.log(copiedBuf.toString())
// Affiche : cuffer

console.log(buf.toString())
// Affiche : buffer

// Avec buf.slice(), le buffer original est modifié.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Affiche : cuffer
console.log(buf.toString())
// Affiche également : cuffer (!)

const { Buffer } = require('node:buffer')

const buf = Buffer.from('buffer')

const copiedBuf = Uint8Array.prototype.slice.call(buf)
copiedBuf[0]++
console.log(copiedBuf.toString())
// Affiche : cuffer

console.log(buf.toString())
// Affiche : buffer

// Avec buf.slice(), le buffer original est modifié.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Affiche : cuffer
console.log(buf.toString())
// Affiche également : cuffer (!)

`buf.swap16()`

Ajouté dans : v5.10.0

Retourne : <Buffer> Une référence à buf.

Interprète buf comme un tableau d’entiers non signés de 16 bits et inverse l’ordre des octets sur place. Lève une exception ERR_INVALID_BUFFER_SIZE si buf.length n’est pas un multiple de 2.

ESMCJS

import { Buffer } from 'node:buffer'

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

console.log(buf1)
// Affiche : <Buffer 01 02 03 04 05 06 07 08>

buf1.swap16()

console.log(buf1)
// Affiche : <Buffer 02 01 04 03 06 05 08 07>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap16()
// Lève ERR_INVALID_BUFFER_SIZE.

const { Buffer } = require('node:buffer')

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

console.log(buf1)
// Affiche : <Buffer 01 02 03 04 05 06 07 08>

buf1.swap16()

console.log(buf1)
// Affiche : <Buffer 02 01 04 03 06 05 08 07>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap16()
// Lève ERR_INVALID_BUFFER_SIZE.

Une utilisation pratique de buf.swap16() est d’effectuer une conversion rapide sur place entre UTF-16 little-endian et UTF-16 big-endian :

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // Convertir en texte UTF-16 big-endian.

const { Buffer } = require('node:buffer')

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // Convertir en texte UTF-16 big-endian.

`buf.swap32()`

Ajouté dans : v5.10.0

Retourne : <Buffer> Une référence à buf.

Interprète buf comme un tableau d’entiers non signés de 32 bits et inverse l’ordre des octets sur place. Lève une exception ERR_INVALID_BUFFER_SIZE si buf.length n’est pas un multiple de 4.

ESMCJS

import { Buffer } from 'node:buffer'

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

console.log(buf1)
// Affiche : <Buffer 01 02 03 04 05 06 07 08>

buf1.swap32()

console.log(buf1)
// Affiche : <Buffer 04 03 02 01 08 07 06 05>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap32()
// Lève ERR_INVALID_BUFFER_SIZE.

const { Buffer } = require('node:buffer')

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

console.log(buf1)
// Affiche : <Buffer 01 02 03 04 05 06 07 08>

buf1.swap32()

console.log(buf1)
// Affiche : <Buffer 04 03 02 01 08 07 06 05>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap32()
// Lève ERR_INVALID_BUFFER_SIZE.

`buf.swap64()`

Ajouté dans : v6.3.0

Retourne : <Buffer> Une référence à buf.

Interprète buf comme un tableau de nombres 64 bits et inverse l'ordre des octets sur place. Lève ERR_INVALID_BUFFER_SIZE si buf.length n'est pas un multiple de 8.

ESMCJS

import { Buffer } from 'node:buffer'

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

console.log(buf1)
// Affiche : <Buffer 01 02 03 04 05 06 07 08>

buf1.swap64()

console.log(buf1)
// Affiche : <Buffer 08 07 06 05 04 03 02 01>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap64()
// Lève ERR_INVALID_BUFFER_SIZE.

const { Buffer } = require('node:buffer')

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

console.log(buf1)
// Affiche : <Buffer 01 02 03 04 05 06 07 08>

buf1.swap64()

console.log(buf1)
// Affiche : <Buffer 08 07 06 05 04 03 02 01>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap64()
// Lève ERR_INVALID_BUFFER_SIZE.

`buf.toJSON()`

Ajouté dans : v0.9.2

Retourne : <Object>

Retourne une représentation JSON de buf. JSON.stringify() appelle implicitement cette fonction lors de la conversion en chaîne d'une instance Buffer.

Buffer.from() accepte les objets au format retourné par cette méthode. En particulier, Buffer.from(buf.toJSON()) fonctionne comme Buffer.from(buf).

ESMCJS

import { Buffer } from 'node:buffer'

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

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

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

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

const { Buffer } = require('node:buffer')

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

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

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

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

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

Ajouté dans : v0.1.90

encoding <string> L'encodage de caractères à utiliser. Défaut : 'utf8'.
start <integer> L'offset d'octet à partir duquel commencer le décodage. Défaut : 0.
end <integer> L'offset d'octet auquel arrêter le décodage (non inclus). Défaut : buf.length.
Retourne : <string>

Décode buf en une chaîne de caractères selon l'encodage de caractères spécifié dans encoding. start et end peuvent être passés pour décoder seulement un sous-ensemble de buf.

Si encoding est 'utf8' et qu'une séquence d'octets dans l'entrée n'est pas du UTF-8 valide, alors chaque octet invalide est remplacé par le caractère de remplacement U+FFFD.

La longueur maximale d'une instance de chaîne (en unités de code UTF-16) est disponible sous la forme buffer.constants.MAX_STRING_LENGTH.

ESMCJS

import { Buffer } from 'node:buffer'

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 est la valeur ASCII décimale de 'a'.
  buf1[i] = i + 97
}

console.log(buf1.toString('utf8'))
// Affiche : abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// Affiche : abcde

const buf2 = Buffer.from('tést')

console.log(buf2.toString('hex'))
// Affiche : 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// Affiche : té
console.log(buf2.toString(undefined, 0, 3))
// Affiche : té

const { Buffer } = require('node:buffer')

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 est la valeur ASCII décimale de 'a'.
  buf1[i] = i + 97
}

console.log(buf1.toString('utf8'))
// Affiche : abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// Affiche : abcde

const buf2 = Buffer.from('tést')

console.log(buf2.toString('hex'))
// Affiche : 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// Affiche : té
console.log(buf2.toString(undefined, 0, 3))
// Affiche : té

`buf.values()`

Ajouté dans : v1.1.0

Retourne : <Itérateur>

Crée et retourne un itérateur pour les valeurs (octets) de buf. Cette fonction est appelée automatiquement lorsqu'un Buffer est utilisé dans une instruction for..of.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

for (const value of buf.values()) {
  console.log(value)
}
// Affiche :
//   98
//   117
//   102
//   102
//   101
//   114

for (const value of buf) {
  console.log(value)
}
// Affiche :
//   98
//   117
//   102
//   102
//   101
//   114

const { Buffer } = require('node:buffer')

const buf = Buffer.from('buffer')

for (const value of buf.values()) {
  console.log(value)
}
// Affiche :
//   98
//   117
//   102
//   102
//   101
//   114

for (const value of buf) {
  console.log(value)
}
// Affiche :
//   98
//   117
//   102
//   102
//   101
//   114

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

Ajouté dans : v0.1.90

string <chaîne de caractères> Chaîne de caractères à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer à écrire string. Par défaut : 0.
length <entier> Nombre maximal d'octets à écrire (les octets écrits ne dépasseront pas buf.length - offset). Par défaut : buf.length - offset.
encoding <chaîne de caractères> L'encodage de caractères de string. Par défaut : 'utf8'.
Retourne : <entier> Nombre d'octets écrits.

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

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(256)

const len = buf.write('\u00bd + \u00bc = \u00be', 0)

console.log(`${len} octets : ${buf.toString('utf8', 0, len)}`)
// Affiche : 12 octets : ½ + ¼ = ¾

const buffer = Buffer.alloc(10)

const length = buffer.write('abcd', 8)

console.log(`${length} octets : ${buffer.toString('utf8', 8, 10)}`)
// Affiche : 2 octets : ab

const { Buffer } = require('node:buffer')

const buf = Buffer.alloc(256)

const len = buf.write('\u00bd + \u00bc = \u00be', 0)

console.log(`${len} octets : ${buf.toString('utf8', 0, len)}`)
// Affiche : 12 octets : ½ + ¼ = ¾

const buffer = Buffer.alloc(10)

const length = buffer.write('abcd', 8)

console.log(`${length} octets : ${buffer.toString('utf8', 8, 10)}`)
// Affiche : 2 octets : ab

`buf.writeBigInt64BE(value[, offset])`

Ajouté dans : v12.0.0, v10.20.0

value <bigint> Nombre à écrire dans buf.
offset <integer> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire : 0 \<= offset \<= buf.length - 8. Par défaut : 0.
Retourne : <integer> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en big-endian.

value est interprété et écrit comme un entier signé en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64BE(0x0102030405060708n, 0)

console.log(buf)
// Affiche : <Buffer 01 02 03 04 05 06 07 08>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64BE(0x0102030405060708n, 0)

console.log(buf)
// Affiche : <Buffer 01 02 03 04 05 06 07 08>

`buf.writeBigInt64LE(value[, offset])`

Ajouté dans : v12.0.0, v10.20.0

value <bigint> Nombre à écrire dans buf.
offset <integer> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire : 0 \<= offset \<= buf.length - 8. Par défaut : 0.
Retourne : <integer> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en little-endian.

value est interprété et écrit comme un entier signé en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64LE(0x0102030405060708n, 0)

console.log(buf)
// Affiche : <Buffer 08 07 06 05 04 03 02 01>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64LE(0x0102030405060708n, 0)

console.log(buf)
// Affiche : <Buffer 08 07 06 05 04 03 02 01>

`buf.writeBigUInt64BE(value[, offset])`

[Historique]

Version	Modifications
v14.10.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.writeBigUint64BE()`.
v12.0.0, v10.20.0	Ajoutée dans : v12.0.0, v10.20.0

value <bigint> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire : 0 \<= offset \<= buf.length - 8. Par défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en big-endian.

Cette fonction est également disponible sous l'alias writeBigUint64BE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64BE(0xdecafafecacefaden, 0)

console.log(buf)
// Affiche : <Buffer de ca fa fe ca ce fa de>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64BE(0xdecafafecacefaden, 0)

console.log(buf)
// Affiche : <Buffer de ca fa fe ca ce fa de>

`buf.writeBigUInt64LE(value[, offset])`

[Historique]

Version	Modifications
v14.10.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.writeBigUint64LE()`.
v12.0.0, v10.20.0	Ajoutée dans : v12.0.0, v10.20.0

value <bigint> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire : 0 \<= offset \<= buf.length - 8. Par défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en little-endian.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64LE(0xdecafafecacefaden, 0)

console.log(buf)
// Affiche : <Buffer de fa ce ca fe fa ca de>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64LE(0xdecafafecacefaden, 0)

console.log(buf)
// Affiche : <Buffer de fa ce ca fe fa ca de>

Cette fonction est également disponible sous l'alias writeBigUint64LE.

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercition implicite de l'offset en `uint32`.
v0.11.15	Ajouté dans : v0.11.15

value <nombre> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 8. Défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en big-endian. La value doit être un nombre JavaScript. Le comportement est indéfini lorsque value est autre chose qu'un nombre JavaScript.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleBE(123.456, 0)

console.log(buf)
// Affiche : <Buffer 40 5e dd 2f 1a 9f be 77>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleBE(123.456, 0)

console.log(buf)
// Affiche : <Buffer 40 5e dd 2f 1a 9f be 77>

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercition implicite de l'offset en `uint32`.
v0.11.15	Ajouté dans : v0.11.15

value <nombre> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 8. Défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en little-endian. La value doit être un nombre JavaScript. Le comportement est indéfini lorsque value est autre chose qu'un nombre JavaScript.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleLE(123.456, 0)

console.log(buf)
// Affiche : <Buffer 77 be 9f 1a 2f dd 5e 40>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleLE(123.456, 0)

console.log(buf)
// Affiche : <Buffer 77 be 9f 1a 2f dd 5e 40>

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.11.15	Ajouté dans : v0.11.15

value <nombre> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en big-endian. Le comportement est indéfini lorsque value est autre chose qu'un nombre JavaScript.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeFloatBE(0xcafebabe, 0)

console.log(buf)
// Affiche : <Buffer 4f 4a fe bb>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeFloatBE(0xcafebabe, 0)

console.log(buf)
// Affiche : <Buffer 4f 4a fe bb>

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.11.15	Ajouté dans : v0.11.15

value <nombre> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en little-endian. Le comportement est indéfini lorsque value est autre chose qu'un nombre JavaScript.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeFloatLE(0xcafebabe, 0)

console.log(buf)
// Affiche : <Buffer bb fe 4a 4f>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeFloatLE(0xcafebabe, 0)

console.log(buf)
// Affiche : <Buffer bb fe 4a 4f>

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.0	Ajouté dans la version : v0.5.0

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 1. Valeur par défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié. value doit être un entier signé 8 bits valide. Le comportement est indéfini lorsque value est autre chose qu'un entier signé 8 bits.

value est interprété et écrit comme un entier signé en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)

console.log(buf)
// Affiche : <Buffer 02 fe>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(2)

buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)

console.log(buf)
// Affiche : <Buffer 02 fe>

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajouté dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 2. Valeur par défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en big-endian. value doit être un entier signé 16 bits valide. Le comportement est indéfini lorsque value est autre chose qu'un entier signé 16 bits.

value est interprété et écrit comme un entier signé en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt16BE(0x0102, 0)

console.log(buf)
// Affiche : <Buffer 01 02>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(2)

buf.writeInt16BE(0x0102, 0)

console.log(buf)
// Affiche : <Buffer 01 02>

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajouté dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 2. Par défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en little-endian. La value doit être un entier signé 16 bits valide. Le comportement est indéfini lorsque value est autre chose qu'un entier signé 16 bits.

La value est interprétée et écrite comme un entier signé en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt16LE(0x0304, 0)

console.log(buf)
// Affiche : <Buffer 04 03>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(2)

buf.writeInt16LE(0x0304, 0)

console.log(buf)
// Affiche : <Buffer 04 03>

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajouté dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Par défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en big-endian. La value doit être un entier signé 32 bits valide. Le comportement est indéfini lorsque value est autre chose qu'un entier signé 32 bits.

La value est interprétée et écrite comme un entier signé en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeInt32BE(0x01020304, 0)

console.log(buf)
// Affiche : <Buffer 01 02 03 04>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeInt32BE(0x01020304, 0)

console.log(buf)
// Affiche : <Buffer 01 02 03 04>

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

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajouté dans : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Par défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en little-endian. La value doit être un entier signé 32 bits valide. Le comportement est indéfini lorsque value est autre chose qu'un entier signé 32 bits.

La value est interprétée et écrite comme un entier signé en complément à deux.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeInt32LE(0x05060708, 0)

console.log(buf)
// Affiche : <Buffer 08 07 06 05>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeInt32LE(0x05060708, 0)

console.log(buf)
// Affiche : <Buffer 08 07 06 05>

`buf.writeIntBE(value, offset, byteLength)`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset et de `byteLength` en `uint32`.
v0.11.15	Ajouté dans : v0.11.15

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - byteLength.
byteLength <entier> Nombre d'octets à écrire. Doit satisfaire 0 \< byteLength \<= 6.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit byteLength octets de value dans buf à l'offset spécifié en big-endian. Supporte jusqu'à 48 bits de précision. Le comportement est indéfini lorsque value est autre chose qu'un entier signé.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeIntBE(0x1234567890ab, 0, 6)

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

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(6)

buf.writeIntBE(0x1234567890ab, 0, 6)

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

`buf.writeIntLE(value, offset, byteLength)`

[Historique]

Version	Modifications
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset et de `byteLength` en `uint32`.
v0.11.15	Ajouté dans : v0.11.15

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - byteLength.
byteLength <entier> Nombre d'octets à écrire. Doit satisfaire 0 \< byteLength \<= 6.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit byteLength octets de value dans buf à l'offset spécifié en little-endian. Supporte jusqu'à 48 bits de précision. Le comportement est indéfini lorsque value est autre chose qu'un entier signé.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeIntLE(0x1234567890ab, 0, 6)

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

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(6)

buf.writeIntLE(0x1234567890ab, 0, 6)

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

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

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom de `buf.writeUint8()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.0	Ajouté dans : v0.5.0

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 1. Valeur par défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié. value doit être un entier sans signe valide sur 8 bits. Le comportement est indéfini lorsque value est autre chose qu'un entier sans signe sur 8 bits.

Cette fonction est également disponible sous l'alias writeUint8.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt8(0x3, 0)
buf.writeUInt8(0x4, 1)
buf.writeUInt8(0x23, 2)
buf.writeUInt8(0x42, 3)

console.log(buf)
// Affiche : <Buffer 03 04 23 42>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt8(0x3, 0)
buf.writeUInt8(0x4, 1)
buf.writeUInt8(0x23, 2)
buf.writeUInt8(0x42, 3)

console.log(buf)
// Affiche : <Buffer 03 04 23 42>

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

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.writeUint16BE()`.
v10.0.0	Suppression de `noAssert` et plus de coercition implicite de l'offset en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 2. Défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en big-endian. La value doit être un entier non signé valide sur 16 bits. Le comportement est indéfini lorsque value est autre chose qu'un entier non signé sur 16 bits.

Cette fonction est également disponible sous l'alias writeUint16BE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)

console.log(buf)
// Affiche : <Buffer de ad be ef>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)

console.log(buf)
// Affiche : <Buffer de ad be ef>

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

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.writeUint16LE()`.
v10.0.0	Suppression de `noAssert` et plus de coercition implicite de l'offset en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 2. Défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en little-endian. La value doit être un entier non signé valide sur 16 bits. Le comportement est indéfini lorsque value est autre chose qu'un entier non signé sur 16 bits.

Cette fonction est également disponible sous l'alias writeUint16LE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

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

console.log(buf)
// Affiche : <Buffer ad de ef be>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

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

console.log(buf)
// Affiche : <Buffer ad de ef be>

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

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom de `buf.writeUint32BE()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en big-endian. La valeur value doit être un entier non signé 32 bits valide. Le comportement est indéfini lorsque value est autre chose qu'un entier non signé 32 bits.

Cette fonction est également disponible sous l'alias writeUint32BE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32BE(0xfeedface, 0)

console.log(buf)
// Affiche : <Buffer fe ed fa ce>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32BE(0xfeedface, 0)

console.log(buf)
// Affiche : <Buffer fe ed fa ce>

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

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom de `buf.writeUint32LE()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - 4. Défaut : 0.
Retourne : <entier> offset plus le nombre d'octets écrits.

Écrit value dans buf à l'offset spécifié en little-endian. La valeur value doit être un entier non signé 32 bits valide. Le comportement est indéfini lorsque value est autre chose qu'un entier non signé 32 bits.

Cette fonction est également disponible sous l'alias writeUint32LE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32LE(0xfeedface, 0)

console.log(buf)
// Affiche : <Buffer ce fa ed fe>

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32LE(0xfeedface, 0)

console.log(buf)
// Affiche : <Buffer ce fa ed fe>

`buf.writeUIntBE(value, offset, byteLength)`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.writeUintBE()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset et de `byteLength` en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - byteLength.
byteLength <entier> Nombre d'octets à écrire. Doit satisfaire 0 \< byteLength \<= 6.
Retourne : <entier> offset plus le nombre d'octets écrits.

Cette fonction est également disponible sous l'alias writeUintBE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeUIntBE(0x1234567890ab, 0, 6)

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

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(6)

buf.writeUIntBE(0x1234567890ab, 0, 6)

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

`buf.writeUIntLE(value, offset, byteLength)`

[Historique]

Version	Modifications
v14.9.0, v12.19.0	Cette fonction est également disponible sous le nom `buf.writeUintLE()`.
v10.0.0	Suppression de `noAssert` et plus aucune coercion implicite de l'offset et de `byteLength` en `uint32`.
v0.5.5	Ajoutée dans la version : v0.5.5

value <entier> Nombre à écrire dans buf.
offset <entier> Nombre d'octets à ignorer avant de commencer l'écriture. Doit satisfaire 0 \<= offset \<= buf.length - byteLength.
byteLength <entier> Nombre d'octets à écrire. Doit satisfaire 0 \< byteLength \<= 6.
Retourne : <entier> offset plus le nombre d'octets écrits.

Cette fonction est également disponible sous l'alias writeUintLE.

ESMCJS

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeUIntLE(0x1234567890ab, 0, 6)

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

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(6)

buf.writeUIntLE(0x1234567890ab, 0, 6)

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

`new Buffer(array)`

[Historique]

Version	Modifications
v10.0.0	L'appel de ce constructeur émet un avertissement d'obsolescence lorsqu'il est exécuté à partir de code en dehors du répertoire `node_modules`.
v7.2.1	L'appel de ce constructeur n'émet plus d'avertissement d'obsolescence.
v7.0.0	L'appel de ce constructeur émet désormais un avertissement d'obsolescence.
v6.0.0	Déprécié depuis : v6.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié : utiliser Buffer.from(array) à la place.

array <integer[]> Un tableau d'octets à copier.

Voir Buffer.from(array).

`new Buffer(arrayBuffer[, byteOffset[, length]])`

[Historique]

Version	Modifications
v10.0.0	L'appel de ce constructeur émet un avertissement d'obsolescence lorsqu'il est exécuté à partir de code en dehors du répertoire `node_modules`.
v7.2.1	L'appel de ce constructeur n'émet plus d'avertissement d'obsolescence.
v7.0.0	L'appel de ce constructeur émet désormais un avertissement d'obsolescence.
v6.0.0	Les paramètres `byteOffset` et `length` sont désormais pris en charge.
v6.0.0	Déprécié depuis : v6.0.0
v3.0.0	Ajouté dans : v3.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié : utiliser Buffer.from(arrayBuffer[, byteOffset[, length]]) à la place.

arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Un ArrayBuffer, un SharedArrayBuffer ou la propriété .buffer d'un TypedArray.
byteOffset <integer> Index du premier octet à exposer. Défaut : 0.
length <integer> Nombre d'octets à exposer. Défaut : arrayBuffer.byteLength - byteOffset.

Voir Buffer.from(arrayBuffer[, byteOffset[, length]]).

`new Buffer(buffer)`

[Historique]

Version	Modifications
v10.0.0	L'appel de ce constructeur émet un avertissement d'obsolescence lorsqu'il est exécuté depuis du code en dehors du répertoire `node_modules`.
v7.2.1	L'appel de ce constructeur n'émet plus d'avertissement d'obsolescence.
v7.0.0	L'appel de ce constructeur émet désormais un avertissement d'obsolescence.
v6.0.0	Déprécié depuis : v6.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stability : 0 - Déprécié : Utilisez Buffer.from(buffer) à la place.

buffer <Buffer> | <Uint8Array> Un Buffer existant ou un Uint8Array à partir duquel copier les données.

Voir Buffer.from(buffer).

`new Buffer(size)`

[Historique]

Version	Modifications
v10.0.0	L'appel de ce constructeur émet un avertissement d'obsolescence lorsqu'il est exécuté depuis du code en dehors du répertoire `node_modules`.
v8.0.0	`new Buffer(size)` renverra une mémoire remplie de zéros par défaut.
v7.2.1	L'appel de ce constructeur n'émet plus d'avertissement d'obsolescence.
v7.0.0	L'appel de ce constructeur émet désormais un avertissement d'obsolescence.
v6.0.0	Déprécié depuis : v6.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stability : 0 - Déprécié : Utilisez Buffer.alloc() à la place (voir aussi Buffer.allocUnsafe()).

size <entier> La longueur souhaitée du nouveau Buffer.

Voir Buffer.alloc() et Buffer.allocUnsafe(). Cette variante du constructeur est équivalente à Buffer.alloc().

`new Buffer(string[, encoding])`

[Historique]

Version	Modifications
v10.0.0	L'appel de ce constructeur émet un avertissement de dépréciation lorsqu'il est exécuté à partir de code en dehors du répertoire `node_modules`.
v7.2.1	L'appel de ce constructeur n'émet plus d'avertissement de dépréciation.
v7.0.0	L'appel de ce constructeur émet désormais un avertissement de dépréciation.
v6.0.0	Déprécié depuis : v6.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié : Utilisez Buffer.from(string[, encoding]) à la place.

string <string> Chaîne à encoder.
encoding <string> L'encodage de string. Par défaut : 'utf8'.

Voir Buffer.from(string[, encoding]).

Classe : `File`

[Historique]

Version	Modifications
v23.0.0	Rend les instances de File clonables.
v20.0.0	N'est plus expérimental.
v19.2.0, v18.13.0	Ajouté dans : v19.2.0, v18.13.0

Étend : <Blob>

Un File fournit des informations sur les fichiers.

`new buffer.File(sources, fileName[, options])`

Ajouté dans : v19.2.0, v18.13.0

sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> | <File[]> Un tableau d'objets string, <ArrayBuffer>, <TypedArray>, <DataView>, <File> ou <Blob>, ou toute combinaison de ces objets, qui seront stockés dans le File.
fileName <string> Le nom du fichier.
options <Object>
- endings <string> 'transparent' ou 'native'. Lorsque défini sur 'native', les sauts de ligne dans les parties sources de chaîne seront convertis en saut de ligne natif de la plateforme, comme spécifié par require('node:os').EOL.
- type <string> Le type de contenu du fichier.
- lastModified <number> La date de dernière modification du fichier. Par défaut : Date.now().

`file.name`

Ajouté dans : v19.2.0, v18.13.0

Type : <string>

Le nom du fichier File.

`file.lastModified`

Ajouté dans : v19.2.0, v18.13.0

Type : <number>

La date de dernière modification du fichier File.

API du module `node:buffer`

Bien que l'objet Buffer soit disponible globalement, il existe des API supplémentaires liées à Buffer qui sont disponibles uniquement via le module node:buffer accessible à l'aide de require('node:buffer').

`buffer.atob(data)`

Ajouté dans : v15.13.0, v14.17.0

[Stable : 3 - Hérité]

Stable : 3 Stabilité : 3 - Hérité. Utilisez Buffer.from(data, 'base64') à la place.

data <any> La chaîne d'entrée codée en Base64.

Décode une chaîne de données codées en Base64 en octets, et encode ces octets en une chaîne en utilisant Latin-1 (ISO-8859-1).

data peut être n'importe quelle valeur JavaScript pouvant être convertie en chaîne.

Cette fonction n'est fournie que pour la compatibilité avec les API héritées de la plateforme web et ne doit jamais être utilisée dans du nouveau code, car elles utilisent des chaînes pour représenter des données binaires et sont antérieures à l'introduction des tableaux typés en JavaScript. Pour le code exécuté à l'aide des API Node.js, la conversion entre les chaînes codées en base64 et les données binaires doit être effectuée à l'aide de Buffer.from(str, 'base64') et de buf.toString('base64').

`buffer.btoa(data)`

Ajouté dans : v15.13.0, v14.17.0

[Stable : 3 - Hérité]

Stable : 3 Stabilité : 3 - Hérité. Utilisez buf.toString('base64') à la place.

data <any> Une chaîne ASCII (Latin1).

Décode une chaîne en octets en utilisant Latin-1 (ISO-8859), et encode ces octets en une chaîne en utilisant Base64.

data peut être n'importe quelle valeur JavaScript pouvant être convertie en chaîne.

`buffer.isAscii(input)`

Ajouté dans : v19.6.0, v18.15.0

input <Buffer> | <ArrayBuffer> | <TypedArray> L'entrée à valider.
Retourne : <boolean>

Cette fonction retourne true si input contient uniquement des données valides encodées en ASCII, y compris le cas où input est vide.

Lève une exception si input est un tampon de tableau détaché.

`buffer.isUtf8(input)`

Ajouté dans : v19.4.0, v18.14.0

input <Buffer> | <ArrayBuffer> | <TypedArray> L'entrée à valider.
Retourne : <boolean>

Cette fonction retourne true si input contient uniquement des données valides encodées en UTF-8, y compris le cas où input est vide.

Lève une exception si input est un tampon de tableau détaché.

`buffer.INSPECT_MAX_BYTES`

Ajouté dans : v0.5.4

<integer> Défaut : 50

Retourne le nombre maximal d'octets qui seront retournés lorsque buf.inspect() est appelé. Cela peut être remplacé par les modules utilisateur. Voir util.inspect() pour plus de détails sur le comportement de buf.inspect().

`buffer.kMaxLength`

Ajouté dans : v3.0.0

<integer> La taille maximale autorisée pour une seule instance Buffer.

Un alias pour buffer.constants.MAX_LENGTH.

`buffer.kStringMaxLength`

Ajouté dans : v3.0.0

<integer> La longueur maximale autorisée pour une seule instance string.

Un alias pour buffer.constants.MAX_STRING_LENGTH.

`buffer.resolveObjectURL(id)`

Ajouté dans : v16.7.0

[Stable : 1 - Expérimental]

Stable : 1 Stabilité : 1 - Expérimental

id <string> Une chaîne d’URL 'blob:nodedata:... renvoyée par un appel précédent à URL.createObjectURL().
Retourne : <Blob>

Résout une URL 'blob:nodedata:... en un objet <Blob> associé enregistré à l’aide d’un appel précédent à URL.createObjectURL().

`buffer.transcode(source, fromEnc, toEnc)`

[Historique]

Version	Modifications
v8.0.0	Le paramètre `source` peut maintenant être un `Uint8Array`.
v7.1.0	Ajouté dans : v7.1.0

source <Buffer> | <Uint8Array> Une instance Buffer ou Uint8Array.
fromEnc <string> L’encodage actuel.
toEnc <string> L’encodage cible.
Retourne : <Buffer>

Recode l’instance Buffer ou Uint8Array donnée d’un encodage de caractères à un autre. Renvoie une nouvelle instance Buffer.

Lève une exception si fromEnc ou toEnc spécifient des encodages de caractères invalides ou si la conversion de fromEnc à toEnc n’est pas autorisée.

Les encodages pris en charge par buffer.transcode() sont : 'ascii', 'utf8', 'utf16le', 'ucs2', 'latin1' et 'binary'.

Le processus de transcodage utilisera des caractères de substitution si une séquence d’octets donnée ne peut pas être correctement représentée dans l’encodage cible. Par exemple :

ESMCJS

import { Buffer, transcode } from 'node:buffer'

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Affiche : '?'

const { Buffer, transcode } = require('node:buffer')

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Affiche : '?'

Le symbole euro (€) n’étant pas représentable en US-ASCII, il est remplacé par ? dans le Buffer transcodé.

Classe : `SlowBuffer`

Dépréciée depuis : v6.0.0

[Stable : 0 - Dépréciée]

Stable : 0 Stability : 0 - Dépréciée : Utilisez Buffer.allocUnsafeSlow() à la place.

Voir Buffer.allocUnsafeSlow(). Il ne s'agissait jamais d'une classe au sens où le constructeur retournait toujours une instance Buffer, plutôt qu'une instance SlowBuffer.

`new SlowBuffer(size)`

Dépréciée depuis : v6.0.0

[Stable : 0 - Dépréciée]

Stable : 0 Stability : 0 - Dépréciée : Utilisez Buffer.allocUnsafeSlow() à la place.

size <entier> La longueur souhaitée du nouveau SlowBuffer.

Voir Buffer.allocUnsafeSlow().

Constantes Buffer

Ajouté dans : v8.2.0

`buffer.constants.MAX_LENGTH`

[Historique]

Version	Modifications
v22.0.0	La valeur est changée en 2 - 1 sur les architectures 64 bits.
v15.0.0	La valeur est changée en 2 sur les architectures 64 bits.
v14.0.0	La valeur est changée de 2 - 1 à 2 - 1 sur les architectures 64 bits.
v8.2.0	Ajouté dans : v8.2.0

<entier> La taille maximale autorisée pour une seule instance Buffer.

Sur les architectures 32 bits, cette valeur est actuellement de 2 - 1 (environ 1 Gio).

Sur les architectures 64 bits, cette valeur est actuellement de 2 - 1 (environ 8 Pio).

Elle reflète v8::TypedArray::kMaxLength en interne.

Cette valeur est également disponible sous forme de buffer.kMaxLength.

`buffer.constants.MAX_STRING_LENGTH`

Ajouté dans : v8.2.0

<entier> La longueur maximale autorisée pour une seule instance string.

Représente la plus grande longueur qu'une primitive string peut avoir, comptée en unités de code UTF-16.

Cette valeur peut dépendre du moteur JS utilisé.

`Buffer.from()`, `Buffer.alloc()`, et `Buffer.allocUnsafe()`

Dans les versions de Node.js antérieures à la 6.0.0, les instances Buffer étaient créées à l'aide de la fonction constructrice Buffer, qui allouait le Buffer retourné différemment selon les arguments fournis :

Passer un nombre comme premier argument à Buffer() (par exemple : new Buffer(10)) alloue un nouvel objet Buffer de la taille spécifiée. Avant Node.js 8.0.0, la mémoire allouée pour de telles instances Buffer n'est pas initialisée et peut contenir des données sensibles. De telles instances Buffer doivent être ensuite initialisées en utilisant soit buf.fill(0) soit en écrivant dans l'intégralité du Buffer avant de lire des données depuis le Buffer. Bien que ce comportement soit intentionnel pour améliorer les performances, l'expérience de développement a démontré qu'une distinction plus explicite est nécessaire entre la création d'un Buffer rapide mais non initialisé et la création d'un Buffer plus lent mais plus sûr. Depuis Node.js 8.0.0, Buffer(num) et new Buffer(num) retournent un Buffer avec une mémoire initialisée.
Passer une chaîne de caractères, un tableau ou un Buffer comme premier argument copie les données de l'objet passé dans le Buffer.
Passer un ArrayBuffer ou un SharedArrayBuffer retourne un Buffer qui partage la mémoire allouée avec le tampon de tableau donné.

Étant donné que le comportement de new Buffer() est différent selon le type du premier argument, des problèmes de sécurité et de fiabilité peuvent être introduits par inadvertance dans les applications lorsque la validation des arguments ou l'initialisation du Buffer n'est pas effectuée.

Par exemple, si un attaquant peut amener une application à recevoir un nombre lorsqu'une chaîne de caractères est attendue, l'application peut appeler new Buffer(100) au lieu de new Buffer("100"), ce qui l'amène à allouer un tampon de 100 octets au lieu d'allouer un tampon de 3 octets avec le contenu "100". Ceci est généralement possible en utilisant des appels d'API JSON. Le JSON faisant la distinction entre les types numériques et les chaînes de caractères, il permet l'injection de nombres là où une application écrite naïvement qui ne valide pas suffisamment ses entrées pourrait s'attendre à toujours recevoir une chaîne de caractères. Avant Node.js 8.0.0, le tampon de 100 octets pouvait contenir des données arbitraires préexistantes en mémoire, pouvant ainsi être utilisé pour exposer des secrets en mémoire à un attaquant distant. Depuis Node.js 8.0.0, l'exposition de la mémoire ne peut plus se produire car les données sont remplies de zéros. Cependant, d'autres attaques sont toujours possibles, telles que la création de tampons très volumineux par le serveur, entraînant une dégradation des performances ou un plantage en cas d'épuisement de la mémoire.

Pour rendre la création d'instances Buffer plus fiable et moins sujette aux erreurs, les différentes formes du constructeur new Buffer() ont été dépréciées et remplacées par les méthodes distinctes Buffer.from(), Buffer.alloc(), et Buffer.allocUnsafe().

Les développeurs doivent migrer toutes les utilisations existantes des constructeurs new Buffer() vers l'une de ces nouvelles API.

Buffer.from(array) retourne un nouveau Buffer qui contient une copie des octets fournis.
Buffer.from(arrayBuffer[, byteOffset[, length]]) retourne un nouveau Buffer qui partage la même mémoire allouée que le ArrayBuffer donné.
Buffer.from(buffer) retourne un nouveau Buffer qui contient une copie du contenu du Buffer donné.
Buffer.from(string[, encoding]) retourne un nouveau Buffer qui contient une copie de la chaîne de caractères fournie.
Buffer.alloc(size[, fill[, encoding]]) retourne un nouveau Buffer initialisé de la taille spécifiée. Cette méthode est plus lente que Buffer.allocUnsafe(size) mais garantit que les nouvelles instances Buffer créées ne contiennent jamais d'anciennes données potentiellement sensibles. Une erreur TypeError sera levée si size n'est pas un nombre.
Buffer.allocUnsafe(size) et Buffer.allocUnsafeSlow(size) retournent chacun un nouveau Buffer non initialisé de la taille size spécifiée. Le Buffer n'étant pas initialisé, le segment de mémoire alloué peut contenir d'anciennes données potentiellement sensibles.

Les instances Buffer retournées par Buffer.allocUnsafe(), Buffer.from(string), Buffer.concat() et Buffer.from(array) peuvent être allouées à partir d'un pool de mémoire interne partagé si size est inférieur ou égal à la moitié de Buffer.poolSize. Les instances retournées par Buffer.allocUnsafeSlow() n'utilisent jamais le pool de mémoire interne partagé.

L'option de ligne de commande `--zero-fill-buffers`

Ajouté dans : v5.10.0

Node.js peut être démarré à l'aide de l'option de ligne de commande --zero-fill-buffers pour que toutes les nouvelles instances de Buffer soient remplies de zéros par défaut lors de leur création. Sans cette option, les tampons créés avec Buffer.allocUnsafe(), Buffer.allocUnsafeSlow(), et new SlowBuffer(size) ne sont pas remplis de zéros. L'utilisation de ce drapeau peut avoir un impact négatif mesurable sur les performances. Utilisez l'option --zero-fill-buffers uniquement si nécessaire pour garantir que les nouvelles instances de Buffer allouées ne peuvent pas contenir d'anciennes données potentiellement sensibles.

bash

$ node --zero-fill-buffers
> Buffer.allocUnsafe(5);
<Buffer 00 00 00 00 00>

Qu'est-ce qui rend `Buffer.allocUnsafe()` et `Buffer.allocUnsafeSlow()` « dangereux » ?

Lors de l'appel de Buffer.allocUnsafe() et de Buffer.allocUnsafeSlow(), le segment de mémoire alloué est non initialisé (il n'est pas mis à zéro). Bien que cette conception rende l'allocation de mémoire assez rapide, le segment de mémoire alloué peut contenir d'anciennes données potentiellement sensibles. L'utilisation d'un Buffer créé par Buffer.allocUnsafe() sans complètement écraser la mémoire peut permettre la fuite de ces anciennes données lors de la lecture de la mémoire du Buffer.

S'il existe des avantages de performance évidents à l'utilisation de Buffer.allocUnsafe(), un soin particulier doit être apporté afin d'éviter d'introduire des failles de sécurité dans une application.

Buffer ​

Tampons et encodage de caractères ​

Tampons et TypedArrays ​

Tampons et itération ​

Classe : Blob ​

new buffer.Blob([sources[, options]]) ​

blob.arrayBuffer() ​

blob.bytes() ​

blob.size ​

blob.slice([start[, end[, type]]]) ​

blob.stream() ​

blob.text() ​

blob.type ​

Objets Blob et MessageChannel ​

Classe : Buffer ​

Méthode statique : Buffer.alloc(size[, fill[, encoding]]) ​

Méthode statique : Buffer.allocUnsafe(size) ​

Méthode statique : Buffer.allocUnsafeSlow(size) ​

Méthode statique : Buffer.byteLength(string[, encoding]) ​

Méthode statique : Buffer.compare(buf1, buf2) ​

Méthode statique : Buffer.concat(list[, totalLength]) ​

Méthode statique : Buffer.copyBytesFrom(view[, offset[, length]]) ​

Méthode statique : Buffer.from(array) ​

Méthode statique : Buffer.from(arrayBuffer[, byteOffset[, length]]) ​

Méthode statique : Buffer.from(buffer) ​

Méthode statique : Buffer.from(object[, offsetOrEncoding[, length]]) ​

Méthode statique : Buffer.from(string[, encoding]) ​

Méthode statique : Buffer.isBuffer(obj) ​

Méthode statique : Buffer.isEncoding(encoding) ​

Propriété de classe : Buffer.poolSize ​

buf[index] ​

buf.buffer ​

buf.byteOffset ​

buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]]) ​

buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]]) ​

buf.entries() ​

buf.equals(otherBuffer) ​

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

buf.includes(value[, byteOffset][, encoding]) ​

buf.indexOf(value[, byteOffset][, encoding]) ​

buf.keys() ​

buf.lastIndexOf(value[, byteOffset][, encoding]) ​

buf.length ​

buf.parent ​

buf.readBigInt64BE([offset]) ​

buf.readBigInt64LE([offset]) ​

buf.readBigUInt64BE([offset]) ​

buf.readBigUInt64LE([offset]) ​

buf.readDoubleBE([offset]) ​

buf.readDoubleLE([offset]) ​

buf.readFloatBE([offset]) ​

buf.readFloatLE([offset]) ​

buf.readInt8([offset]) ​

buf.readInt16BE([offset]) ​

buf.readInt16LE([offset]) ​

buf.readInt32BE([offset]) ​

buf.readInt32LE([offset]) ​

buf.readIntBE(offset, byteLength) ​

buf.readIntLE(offset, byteLength) ​

buf.readUInt8([offset]) ​

buf.readUInt16BE([offset]) ​

buf.readUInt16LE([offset]) ​

buf.readUInt32BE([offset]) ​

buf.readUInt32LE([offset]) ​

buf.readUIntBE(offset, byteLength) ​

buf.readUIntLE(offset, byteLength) ​

buf.subarray([start[, end]]) ​

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

buf.swap16() ​

buf.swap32() ​

buf.swap64() ​

buf.toJSON() ​

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

buf.values() ​

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

buf.writeBigInt64BE(value[, offset]) ​

buf.writeBigInt64LE(value[, offset]) ​

buf.writeBigUInt64BE(value[, offset]) ​

buf.writeBigUInt64LE(value[, offset]) ​

buf.writeDoubleBE(value[, offset]) ​

Buffer

Tampons et encodage de caractères

Tampons et TypedArrays

Tampons et itération

Classe : `Blob`

`new buffer.Blob([sources[, options]])`

`blob.arrayBuffer()`

`blob.bytes()`

`blob.size`

`blob.slice([start[, end[, type]]])`

`blob.stream()`

`blob.text()`

`blob.type`

Objets `Blob` et `MessageChannel`

Classe : `Buffer`

Méthode statique : `Buffer.alloc(size[, fill[, encoding]])`

Méthode statique : `Buffer.allocUnsafe(size)`

Méthode statique : `Buffer.allocUnsafeSlow(size)`

Méthode statique : `Buffer.byteLength(string[, encoding])`

Méthode statique : `Buffer.compare(buf1, buf2)`

Méthode statique : `Buffer.concat(list[, totalLength])`

Méthode statique : `Buffer.copyBytesFrom(view[, offset[, length]])`

Méthode statique : `Buffer.from(array)`

Méthode statique : `Buffer.from(arrayBuffer[, byteOffset[, length]])`

Méthode statique : `Buffer.from(buffer)`

Méthode statique : `Buffer.from(object[, offsetOrEncoding[, length]])`

Méthode statique : `Buffer.from(string[, encoding])`

Méthode statique : `Buffer.isBuffer(obj)`

Méthode statique : `Buffer.isEncoding(encoding)`

Propriété de classe : `Buffer.poolSize`

`buf[index]`

`buf.buffer`

`buf.byteOffset`

`buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])`

`buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])`

`buf.entries()`

`buf.equals(otherBuffer)`

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

`buf.includes(value[, byteOffset][, encoding])`

`buf.indexOf(value[, byteOffset][, encoding])`

`buf.keys()`

`buf.lastIndexOf(value[, byteOffset][, encoding])`

`buf.length`

`buf.parent`

`buf.readBigInt64BE([offset])`

`buf.readBigInt64LE([offset])`

`buf.readBigUInt64BE([offset])`

`buf.readBigUInt64LE([offset])`

`buf.readDoubleBE([offset])`

`buf.readDoubleLE([offset])`

`buf.readFloatBE([offset])`

`buf.readFloatLE([offset])`

`buf.readInt8([offset])`

`buf.readInt16BE([offset])`

`buf.readInt16LE([offset])`

`buf.readInt32BE([offset])`

`buf.readInt32LE([offset])`

`buf.readIntBE(offset, byteLength)`

`buf.readIntLE(offset, byteLength)`

`buf.readUInt8([offset])`

`buf.readUInt16BE([offset])`

`buf.readUInt16LE([offset])`

`buf.readUInt32BE([offset])`

`buf.readUInt32LE([offset])`

`buf.readUIntBE(offset, byteLength)`

`buf.readUIntLE(offset, byteLength)`

`buf.subarray([start[, end]])`

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

`buf.swap16()`

`buf.swap32()`

`buf.swap64()`

`buf.toJSON()`

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

`buf.values()`

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

`buf.writeBigInt64BE(value[, offset])`

`buf.writeBigInt64LE(value[, offset])`

`buf.writeBigUInt64BE(value[, offset])`

`buf.writeBigUInt64LE(value[, offset])`

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