Buffer

[Stable: 2 - Stable]

Stable: 2 Estabilidade: 2 - Estável

Código Fonte: lib/buffer.js

Objetos Buffer são usados para representar uma sequência de bytes de comprimento fixo. Muitas APIs do Node.js suportam Buffers.

A classe Buffer é uma subclasse da classe Uint8Array do JavaScript e a estende com métodos que cobrem casos de uso adicionais. As APIs do Node.js aceitam Uint8Arrays simples onde Buffers também são suportados.

Embora a classe Buffer esteja disponível no escopo global, ainda é recomendável referenciá-la explicitamente por meio de uma declaração import ou require.

ESM

import { Buffer } from 'node:buffer'

// Cria um Buffer preenchido com zeros de comprimento 10.
const buf1 = Buffer.alloc(10)

// Cria um Buffer de comprimento 10,
// preenchido com bytes que todos têm o valor `1`.
const buf2 = Buffer.alloc(10, 1)

// Cria um buffer não inicializado de comprimento 10.
// Isso é mais rápido do que chamar Buffer.alloc() mas a instância Buffer retornada
// pode conter dados antigos que precisam ser
// sobrescritos usando fill(), write() ou outras funções que preenchem os
// conteúdos do Buffer.
const buf3 = Buffer.allocUnsafe(10)

// Cria um Buffer contendo os bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3])

// Cria um Buffer contendo os bytes [1, 1, 1, 1] – as entradas
// são todas truncadas usando `(value & 255)` para caber no intervalo de 0 a 255.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Cria um Buffer contendo os bytes codificados em UTF-8 para a string 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (em notação hexadecimal)
// [116, 195, 169, 115, 116] (em notação decimal)
const buf6 = Buffer.from('tést')

// Cria um Buffer contendo os bytes Latin-1 [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1')

CJS

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

// Cria um Buffer preenchido com zeros de comprimento 10.
const buf1 = Buffer.alloc(10)

// Cria um Buffer de comprimento 10,
// preenchido com bytes que todos têm o valor `1`.
const buf2 = Buffer.alloc(10, 1)

// Cria um buffer não inicializado de comprimento 10.
// Isso é mais rápido do que chamar Buffer.alloc() mas a instância Buffer retornada
// pode conter dados antigos que precisam ser
// sobrescritos usando fill(), write() ou outras funções que preenchem os
// conteúdos do Buffer.
const buf3 = Buffer.allocUnsafe(10)

// Cria um Buffer contendo os bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3])

// Cria um Buffer contendo os bytes [1, 1, 1, 1] – as entradas
// são todas truncadas usando `(value & 255)` para caber no intervalo de 0 a 255.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Cria um Buffer contendo os bytes codificados em UTF-8 para a string 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (em notação hexadecimal)
// [116, 195, 169, 115, 116] (em notação decimal)
const buf6 = Buffer.from('tést')

// Cria um Buffer contendo os bytes Latin-1 [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1')

Buffers e codificações de caracteres

[Histórico]

Versão	Mudanças
v15.7.0, v14.18.0	Introduzida a codificação base64url.
v6.4.0	Introduzido latin1 como um alias para binary.
v5.0.0	Removidas as codificações raw e raws obsoletas.

Ao converter entre Buffers e strings, uma codificação de caracteres pode ser especificada. Se nenhuma codificação de caracteres for especificada, UTF-8 será usado como padrão.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('olá mundo', 'utf8')

console.log(buf.toString('hex'))
// Imprime: 6f6c61206d756e646f
console.log(buf.toString('base64'))
// Imprime: b2xhIG11bmRv

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

CJS

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

const buf = Buffer.from('olá mundo', 'utf8')

console.log(buf.toString('hex'))
// Imprime: 6f6c61206d756e646f
console.log(buf.toString('base64'))
// Imprime: b2xhIG11bmRv

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

Buffers do Node.js aceitam todas as variações de caso de strings de codificação que recebem. Por exemplo, UTF-8 pode ser especificado como 'utf8', 'UTF8' ou 'uTf8'.

As codificações de caracteres atualmente suportadas pelo Node.js são as seguintes:

• 'utf8' (alias: 'utf-8'): Caracteres Unicode codificados com vários bytes. Muitas páginas da web e outros formatos de documentos usam UTF-8. Esta é a codificação de caracteres padrão. Ao decodificar um Buffer em uma string que não contém exclusivamente dados UTF-8 válidos, o caractere de substituição Unicode U+FFFD � será usado para representar esses erros.
• 'utf16le' (alias: 'utf-16le'): Caracteres Unicode codificados com vários bytes. Diferentemente de 'utf8', cada caractere na string será codificado usando 2 ou 4 bytes. O Node.js suporta apenas a variante little-endian de UTF-16.
• 'latin1': Latin-1 significa ISO-8859-1. Esta codificação de caracteres suporta apenas os caracteres Unicode de U+0000 a U+00FF. Cada caractere é codificado usando um único byte. Caracteres que não se encaixam nesse intervalo são truncados e serão mapeados para caracteres nesse intervalo.

Converter um Buffer em uma string usando um dos itens acima é conhecido como decodificação, e converter uma string em um Buffer é conhecido como codificação.

O Node.js também suporta as seguintes codificações de binário para texto. Para codificações de binário para texto, a convenção de nomenclatura é invertida: Converter um Buffer em uma string é normalmente referido como codificação e converter uma string em um Buffer como decodificação.

• 'base64': Codificação Base64. Ao criar um Buffer a partir de uma string, esta codificação também aceitará corretamente o "Alfabeto Seguro para URL e Nome de Arquivo", conforme especificado em RFC 4648, Seção 5. Caracteres de espaço em branco, como espaços, tabulações e novas linhas contidos na string codificada em base64, são ignorados.
• 'base64url': Codificação base64url, conforme especificado em RFC 4648, Seção 5. Ao criar um Buffer a partir de uma string, esta codificação também aceitará corretamente strings codificadas em base64 regulares. Ao codificar um Buffer em uma string, esta codificação omitirá o preenchimento.
• 'hex': Codifica cada byte como dois caracteres hexadecimais. O truncamento de dados pode ocorrer ao decodificar strings que não consistem exclusivamente em um número par de caracteres hexadecimais. Veja abaixo um exemplo.

As seguintes codificações de caracteres legadas também são suportadas:

• 'ascii': Apenas para dados ASCII de 7 bits. Ao codificar uma string em um Buffer, isso é equivalente a usar 'latin1'. Ao decodificar um Buffer em uma string, usar essa codificação também irá desconfigurar o bit mais alto de cada byte antes da decodificação como 'latin1'. Geralmente, não deve haver motivo para usar esta codificação, pois 'utf8' (ou, se os dados forem conhecidos como sempre somente ASCII, 'latin1') será uma escolha melhor ao codificar ou decodificar texto somente ASCII. Ele é fornecido apenas para compatibilidade legada.
• 'binary': Alias para 'latin1'. O nome desta codificação pode ser muito enganoso, pois todas as codificações listadas aqui convertem entre strings e dados binários. Para converter entre strings e Buffers, normalmente 'utf8' é a escolha certa.
• 'ucs2', 'ucs-2': Aliases de 'utf16le'. UCS-2 costumava se referir a uma variante de UTF-16 que não suportava caracteres que tinham pontos de código maiores que U+FFFF. No Node.js, esses pontos de código são sempre suportados.

ESM

import { Buffer } from 'node:buffer'

Buffer.from('1ag123', 'hex')
// Imprime <Buffer 1a>, dados truncados quando o primeiro valor não hexadecimal
// ('g') encontrado.

Buffer.from('1a7', 'hex')
// Imprime <Buffer 1a>, dados truncados quando os dados terminam em um único dígito ('7').

Buffer.from('1634', 'hex')
// Imprime <Buffer 16 34>, todos os dados representados.

CJS

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

Buffer.from('1ag123', 'hex')
// Imprime <Buffer 1a>, dados truncados quando o primeiro valor não hexadecimal
// ('g') encontrado.

Buffer.from('1a7', 'hex')
// Imprime <Buffer 1a>, dados truncados quando os dados terminam em um único dígito ('7').

Buffer.from('1634', 'hex')
// Imprime <Buffer 16 34>, todos os dados representados.

Os navegadores da Web modernos seguem o WHATWG Encoding Standard, que associa 'latin1' e 'ISO-8859-1' a 'win-1252'. Isso significa que, ao fazer algo como http.get(), se o conjunto de caracteres retornado for um dos listados na especificação WHATWG, é possível que o servidor realmente tenha retornado dados codificados em 'win-1252' e o uso da codificação 'latin1' pode decodificar os caracteres incorretamente.

Buffers e TypedArrays

[Histórico]

Versão	Mudanças
v3.0.0	A classe Buffer agora herda de Uint8Array.

Instâncias de Buffer também são instâncias de JavaScript Uint8Array e TypedArray. Todos os métodos de TypedArray estão disponíveis em Buffers. No entanto, existem incompatibilidades sutis entre a API Buffer e a API TypedArray.

Em particular:

• Enquanto TypedArray.prototype.slice() cria uma cópia de parte do TypedArray, Buffer.prototype.slice() cria uma visualização sobre o Buffer existente sem copiar. Esse comportamento pode ser surpreendente e existe apenas para compatibilidade legada. TypedArray.prototype.subarray() pode ser usado para alcançar o comportamento de Buffer.prototype.slice() tanto em Buffers quanto em outros TypedArrays e deve ser preferido.
• buf.toString() é incompatível com seu equivalente TypedArray.
• Vários métodos, por exemplo, buf.indexOf(), suportam argumentos adicionais.

Existem duas maneiras de criar novas instâncias de TypedArray a partir de um Buffer:

• Passar um Buffer para um construtor TypedArray copiará o conteúdo do Buffer, interpretado como um array de inteiros, e não como uma sequência de bytes do tipo de destino.

ESM

import { Buffer } from 'node:buffer'

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

console.log(uint32array)

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

CJS

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

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

console.log(uint32array)

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

• Passar o ArrayBuffer subjacente do Buffer criará um TypedArray que compartilha sua memória com o Buffer.

ESM

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)

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

CJS

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)

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

É possível criar um novo Buffer que compartilhe a mesma memória alocada que uma instância de TypedArray usando a propriedade .buffer do objeto TypedArray da mesma maneira. Buffer.from() se comporta como new Uint8Array() neste contexto.

ESM

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

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

// Copia o conteúdo de `arr`.
const buf1 = Buffer.from(arr)

// Compartilha memória com `arr`.
const buf2 = Buffer.from(arr.buffer)

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

arr[1] = 6000

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

CJS

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

const arr = new Uint16Array(2)

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

// Copia o conteúdo de `arr`.
const buf1 = Buffer.from(arr)

// Compartilha memória com `arr`.
const buf2 = Buffer.from(arr.buffer)

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

arr[1] = 6000

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

Ao criar um Buffer usando o .buffer de um TypedArray, é possível usar apenas uma porção do ArrayBuffer subjacente, passando os parâmetros byteOffset e length.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

Buffer.from() e TypedArray.from() têm assinaturas e implementações diferentes. Especificamente, as variantes TypedArray aceitam um segundo argumento que é uma função de mapeamento que é invocada em cada elemento do array tipado:

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

O método Buffer.from(), no entanto, não oferece suporte ao uso de uma função de mapeamento:

• Buffer.from(array)
• Buffer.from(buffer)
• Buffer.from(arrayBuffer[, byteOffset[, length]])
• Buffer.from(string[, encoding])

Buffers e iteração

Instâncias de Buffer podem ser iteradas usando a sintaxe for..of:

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

Além disso, os métodos buf.values(), buf.keys() e buf.entries() podem ser usados para criar iteradores.

Classe: Blob

[Histórico]

Versão	Mudanças
v18.0.0, v16.17.0	Não é mais experimental.
v15.7.0, v14.18.0	Adicionado em: v15.7.0, v14.18.0

Um Blob encapsula dados brutos e imutáveis que podem ser compartilhados com segurança entre vários threads de worker.

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

[Histórico]

Versão	Mudanças
v16.7.0	Adicionada a opção padrão endings para substituir as quebras de linha e removida a opção não padrão encoding.
v15.7.0, v14.18.0	Adicionado em: v15.7.0, v14.18.0

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> Um array de string, objetos <ArrayBuffer>, <TypedArray>, <DataView> ou <Blob>, ou qualquer combinação desses objetos, que serão armazenados no Blob.
• options <Object>
  • endings <string> Um entre 'transparent' ou 'native'. Quando definido como 'native', as quebras de linha nas partes de origem da string serão convertidas para a quebra de linha nativa da plataforma, conforme especificado por require('node:os').EOL.
  • type <string> O tipo de conteúdo do Blob. O objetivo é que type transmita o tipo de mídia MIME dos dados, porém nenhuma validação do formato do tipo é realizada.

Cria um novo objeto Blob contendo uma concatenação das fontes fornecidas.

Fontes <ArrayBuffer>, <TypedArray>, <DataView> e <Buffer> são copiadas para o 'Blob' e, portanto, podem ser modificadas com segurança após a criação do 'Blob'.

Fontes de string são codificadas como sequências de bytes UTF-8 e copiadas para o Blob. Pares substitutos não correspondentes em cada parte da string serão substituídos por caracteres de substituição Unicode U+FFFD.

blob.arrayBuffer()

Adicionado em: v15.7.0, v14.18.0

• Retorna: <Promise>

Retorna uma promise que é resolvida com um <ArrayBuffer> contendo uma cópia dos dados do Blob.

blob.bytes()

Adicionado em: v22.3.0, v20.16.0

O método blob.bytes() retorna o byte do objeto Blob como um Promise<Uint8Array>.

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

blob.size

Adicionado em: v15.7.0, v14.18.0

O tamanho total do Blob em bytes.

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

Adicionado em: v15.7.0, v14.18.0

• start <number> O índice inicial.
• end <number> O índice final.
• type <string> O content-type para o novo Blob

Cria e retorna um novo Blob contendo um subconjunto dos dados deste objeto Blob. O Blob original não é alterado.

blob.stream()

Adicionado em: v16.7.0

• Retorna: <ReadableStream>

Retorna um novo ReadableStream que permite que o conteúdo do Blob seja lido.

blob.text()

Adicionado em: v15.7.0, v14.18.0

• Retorna: <Promise>

Retorna uma promise que é resolvida com o conteúdo do Blob decodificado como uma string UTF-8.

blob.type

Adicionado em: v15.7.0, v14.18.0

• Tipo: <string>

O content-type do Blob.

Objetos Blob e MessageChannel

Uma vez que um objeto <Blob> é criado, ele pode ser enviado via MessagePort para múltiplos destinos sem transferir ou copiar imediatamente os dados. Os dados contidos pelo Blob são copiados somente quando os métodos arrayBuffer() ou text() são chamados.

ESM

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)

// O Blob ainda é utilizável após o envio.
blob.text().then(console.log)

CJS

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)

// O Blob ainda é utilizável após o envio.
blob.text().then(console.log)

Classe: Buffer

A classe Buffer é um tipo global para lidar diretamente com dados binários. Ela pode ser construída de diversas maneiras.

Método estático: Buffer.alloc(size[, fill[, encoding]])

[Histórico]

Versão	Mudanças
v20.0.0	Lança ERR_INVALID_ARG_TYPE ou ERR_OUT_OF_RANGE em vez de ERR_INVALID_ARG_VALUE para argumentos de entrada inválidos.
v15.0.0	Lança ERR_INVALID_ARG_VALUE em vez de ERR_INVALID_OPT_VALUE para argumentos de entrada inválidos.
v10.0.0	Tentar preencher um buffer de comprimento diferente de zero com um buffer de comprimento zero aciona uma exceção lançada.
v10.0.0	Especificar uma string inválida para fill aciona uma exceção lançada.
v8.9.3	Especificar uma string inválida para fill agora resulta em um buffer preenchido com zero.
v5.10.0	Adicionado em: v5.10.0

• size <integer> O comprimento desejado do novo Buffer.
• fill <string> | <Buffer> | <Uint8Array> | <integer> Um valor para pré-preencher o novo Buffer. Padrão: 0.
• encoding <string> Se fill for uma string, esta é sua codificação. Padrão: 'utf8'.
• Retorna: <Buffer>

Aloca um novo Buffer de size bytes. Se fill for undefined, o Buffer será preenchido com zero.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(5)

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

CJS

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

const buf = Buffer.alloc(5)

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

Se size for maior que buffer.constants.MAX_LENGTH ou menor que 0, ERR_OUT_OF_RANGE é lançada.

Se fill for especificado, o Buffer alocado será inicializado chamando buf.fill(fill).

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

Se fill e encoding forem especificados, o Buffer alocado será inicializado chamando buf.fill(fill, encoding).

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

Chamar Buffer.alloc() pode ser visivelmente mais lento do que a alternativa Buffer.allocUnsafe(), mas garante que o conteúdo da nova instância de Buffer nunca conterá dados sensíveis de alocações anteriores, incluindo dados que podem não ter sido alocados para Buffers.

Um TypeError será lançado se size não for um número.

Método estático: Buffer.allocUnsafe(size)

[Histórico]

Versão	Mudanças
v20.0.0	Lança ERR_INVALID_ARG_TYPE ou ERR_OUT_OF_RANGE em vez de ERR_INVALID_ARG_VALUE para argumentos de entrada inválidos.
v15.0.0	Lança ERR_INVALID_ARG_VALUE em vez de ERR_INVALID_OPT_VALUE para argumentos de entrada inválidos.
v7.0.0	Passar um size negativo agora irá lançar um erro.
v5.10.0	Adicionado em: v5.10.0

• size <integer> O comprimento desejado do novo Buffer.
• Retorna: <Buffer>

Aloca um novo Buffer de size bytes. Se size for maior que buffer.constants.MAX_LENGTH ou menor que 0, ERR_OUT_OF_RANGE é lançado.

A memória subjacente para instâncias Buffer criadas desta forma não é inicializada. O conteúdo do Buffer recém-criado é desconhecido e pode conter dados confidenciais. Use Buffer.alloc() em vez disso para inicializar instâncias Buffer com zeros.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(10)

console.log(buf)
// Imprime (conteúdo pode variar): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0)

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

CJS

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

const buf = Buffer.allocUnsafe(10)

console.log(buf)
// Imprime (conteúdo pode variar): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0)

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

Um TypeError será lançado se size não for um número.

O módulo Buffer pré-aloca uma instância Buffer interna de tamanho Buffer.poolSize que é usada como um pool para a alocação rápida de novas instâncias Buffer criadas usando Buffer.allocUnsafe(), Buffer.from(array), Buffer.from(string) e Buffer.concat() apenas quando size é menor que Buffer.poolSize \>\>\> 1 (piso de Buffer.poolSize dividido por dois).

O uso deste pool de memória interno pré-alocado é uma diferença chave entre chamar Buffer.alloc(size, fill) vs. Buffer.allocUnsafe(size).fill(fill). Especificamente, Buffer.alloc(size, fill) nunca usará o pool Buffer interno, enquanto Buffer.allocUnsafe(size).fill(fill) usará o pool Buffer interno se size for menor ou igual à metade de Buffer.poolSize. A diferença é sutil, mas pode ser importante quando uma aplicação requer o desempenho adicional que Buffer.allocUnsafe() fornece.

Método estático: Buffer.allocUnsafeSlow(size)

[Histórico]

Versão	Alterações
v20.0.0	Lança ERR_INVALID_ARG_TYPE ou ERR_OUT_OF_RANGE em vez de ERR_INVALID_ARG_VALUE para argumentos de entrada inválidos.
v15.0.0	Lança ERR_INVALID_ARG_VALUE em vez de ERR_INVALID_OPT_VALUE para argumentos de entrada inválidos.
v5.12.0	Adicionado em: v5.12.0

• size <integer> O tamanho desejado do novo Buffer.
• Retorna: <Buffer>

Aloca um novo Buffer de size bytes. Se size for maior que buffer.constants.MAX_LENGTH ou menor que 0, ERR_OUT_OF_RANGE é lançado. Um Buffer de tamanho zero é criado se size for 0.

A memória subjacente para as instâncias de Buffer criadas desta forma não é inicializada. O conteúdo do Buffer recém-criado é desconhecido e pode conter dados confidenciais. Use buf.fill(0) para inicializar tais instâncias de Buffer com zeros.

Ao usar Buffer.allocUnsafe() para alocar novas instâncias de Buffer, alocações menores que Buffer.poolSize \>\>\> 1 (4KiB quando o poolSize padrão é usado) são fatiadas de um único Buffer pré-alocado. Isso permite que os aplicativos evitem a sobrecarga de coleta de lixo da criação de muitas instâncias de Buffer alocadas individualmente. Essa abordagem melhora o desempenho e o uso de memória, eliminando a necessidade de rastrear e limpar tantos objetos ArrayBuffer individuais.

No entanto, no caso em que um desenvolvedor pode precisar reter um pequeno pedaço de memória de um pool por um período indeterminado de tempo, pode ser apropriado criar uma instância de Buffer não agrupada usando Buffer.allocUnsafeSlow() e, em seguida, copiar os bits relevantes.

ESM

import { Buffer } from 'node:buffer'

// Precisa manter alguns pequenos pedaços de memória por perto.
const store = []

socket.on('readable', () => {
  let data
  while (null !== (data = readable.read())) {
    // Alocar para dados retidos.
    const sb = Buffer.allocUnsafeSlow(10)

    // Copiar os dados para a nova alocação.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

CJS

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

// Precisa manter alguns pequenos pedaços de memória por perto.
const store = []

socket.on('readable', () => {
  let data
  while (null !== (data = readable.read())) {
    // Alocar para dados retidos.
    const sb = Buffer.allocUnsafeSlow(10)

    // Copiar os dados para a nova alocação.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

Um TypeError será lançado se size não for um número.

Método estático: Buffer.byteLength(string[, encoding])

[Histórico]

Versão	Mudanças
v7.0.0	Passar uma entrada inválida agora lançará um erro.
v5.10.0	O parâmetro string agora pode ser qualquer TypedArray, DataView ou ArrayBuffer.
v0.1.90	Adicionado em: v0.1.90

• string <string> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> Um valor para calcular o comprimento.
• encoding <string> Se string for uma string, esta é sua codificação. Padrão: 'utf8'.
• Retorna: <integer> O número de bytes contidos em string.

Retorna o comprimento em bytes de uma string quando codificada usando encoding. Isso não é o mesmo que String.prototype.length, que não leva em conta a codificação que é usada para converter a string em bytes.

Para 'base64', 'base64url' e 'hex', esta função assume uma entrada válida. Para strings que contêm dados não codificados em base64/hex (por exemplo, espaço em branco), o valor de retorno pode ser maior do que o comprimento de um Buffer criado a partir da string.

ESM

import { Buffer } from 'node:buffer'

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

console.log(`${str}: ${str.length} caracteres, ` + `${Buffer.byteLength(str, 'utf8')} bytes`)
// Imprime: ½ + ¼ = ¾: 9 caracteres, 12 bytes

CJS

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

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

console.log(`${str}: ${str.length} caracteres, ` + `${Buffer.byteLength(str, 'utf8')} bytes`)
// Imprime: ½ + ¼ = ¾: 9 caracteres, 12 bytes

Quando string é um Buffer/DataView/TypedArray/ArrayBuffer/ SharedArrayBuffer, o comprimento em bytes relatado por .byteLength é retornado.

Método estático: Buffer.compare(buf1, buf2)

[Histórico]

Versão	Mudanças
v8.0.0	Os argumentos agora podem ser Uint8Arrays.
v0.11.13	Adicionado em: v0.11.13

• buf1 <Buffer> | <Uint8Array>
• buf2 <Buffer> | <Uint8Array>
• Retorna: <integer> -1, 0 ou 1, dependendo do resultado da comparação. Veja buf.compare() para detalhes.

Compara buf1 com buf2, normalmente com o objetivo de ordenar arrays de instâncias de Buffer. Isso é equivalente a chamar buf1.compare(buf2).

ESM

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))
// Imprime: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (Este resultado é igual a: [buf2, buf1].)

CJS

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))
// Imprime: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (Este resultado é igual a: [buf2, buf1].)

Método estático: Buffer.concat(list[, totalLength])

[Histórico]

Versão	Mudanças
v8.0.0	Os elementos de list agora podem ser Uint8Arrays.
v0.7.11	Adicionado em: v0.7.11

• list <Buffer[]> | <Uint8Array[]> Lista de instâncias de Buffer ou Uint8Array a serem concatenadas.
• totalLength <integer> Comprimento total das instâncias de Buffer em list quando concatenadas.
• Retorna: <Buffer>

Retorna um novo Buffer que é o resultado da concatenação de todas as instâncias de Buffer em list.

Se a lista não tiver itens, ou se totalLength for 0, um novo Buffer de comprimento zero é retornado.

Se totalLength não for fornecido, ele é calculado a partir das instâncias de Buffer em list somando seus comprimentos.

Se totalLength for fornecido, ele é forçado a um inteiro não assinado. Se o comprimento combinado dos Buffers em list exceder totalLength, o resultado é truncado para totalLength. Se o comprimento combinado dos Buffers em list for menor que totalLength, o espaço restante será preenchido com zeros.

ESM

import { Buffer } from 'node:buffer'

// Cria um único `Buffer` a partir de uma lista de três instâncias de `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)
// Imprime: 42

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

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

CJS

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

// Cria um único `Buffer` a partir de uma lista de três instâncias de `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)
// Imprime: 42

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

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

Buffer.concat() também pode usar o pool interno de Buffer como Buffer.allocUnsafe() faz.

Método estático: Buffer.copyBytesFrom(view[, offset[, length]])

Adicionado em: v19.8.0, v18.16.0

• view <TypedArray> O <TypedArray> a ser copiado.
• offset <integer> O deslocamento inicial dentro de view. Padrão:: 0.
• length <integer> O número de elementos de view a serem copiados. Padrão: view.length - offset.
• Retorna: <Buffer>

Copia a memória subjacente de view para um novo 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étodo estático: Buffer.from(array)

Adicionado em: v5.10.0

• array <integer[]>
• Retorna: <Buffer>

Aloca um novo Buffer usando um array de bytes no intervalo 0 – 255. As entradas do array fora desse intervalo serão truncadas para caber nele.

ESM

import { Buffer } from 'node:buffer'

// Cria um novo Buffer contendo os bytes UTF-8 da string 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

CJS

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

// Cria um novo Buffer contendo os bytes UTF-8 da string 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

Se array for um objeto semelhante a Array (ou seja, um com uma propriedade length do tipo number), ele será tratado como se fosse um array, a menos que seja um Buffer ou um Uint8Array. Isso significa que todas as outras variantes de TypedArray são tratadas como um Array. Para criar um Buffer a partir dos bytes que dão suporte a um TypedArray, use Buffer.copyBytesFrom().

Um TypeError será lançado se array não for um Array ou outro tipo apropriado para as variantes de Buffer.from().

Buffer.from(array) e Buffer.from(string) também podem usar o pool interno de Buffer como Buffer.allocUnsafe() faz.

Método estático: Buffer.from(arrayBuffer[, byteOffset[, length]])

Adicionado em: v5.10.0

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Um ArrayBuffer, SharedArrayBuffer, por exemplo, a propriedade .buffer de um TypedArray.
• byteOffset <integer> Índice do primeiro byte a ser exposto. Padrão: 0.
• length <integer> Número de bytes a serem expostos. Padrão: arrayBuffer.byteLength - byteOffset.
• Retorna: <Buffer>

Isso cria uma visualização do ArrayBuffer sem copiar a memória subjacente. Por exemplo, quando passado uma referência à propriedade .buffer de uma instância de TypedArray, o Buffer recém-criado compartilhará a mesma memória alocada como o ArrayBuffer subjacente do TypedArray.

ESM

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

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

// Compartilha memória com `arr`.
const buf = Buffer.from(arr.buffer)

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

// Alterar o Uint16Array original também altera o Buffer.
arr[1] = 6000

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

CJS

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

const arr = new Uint16Array(2)

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

// Compartilha memória com `arr`.
const buf = Buffer.from(arr.buffer)

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

// Alterar o Uint16Array original também altera o Buffer.
arr[1] = 6000

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

Os argumentos opcionais byteOffset e length especificam um intervalo de memória dentro do arrayBuffer que será compartilhado pelo Buffer.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

Um TypeError será lançado se arrayBuffer não for um ArrayBuffer ou um SharedArrayBuffer ou outro tipo apropriado para variantes de Buffer.from().

É importante lembrar que um ArrayBuffer de apoio pode cobrir um intervalo de memória que se estende além dos limites de uma visualização de TypedArray. Um novo Buffer criado usando a propriedade buffer de um TypedArray pode se estender além do intervalo do TypedArray:

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

Método estático: Buffer.from(buffer)

Adicionado em: v5.10.0

• buffer <Buffer> | <Uint8Array> Um Buffer ou Uint8Array existente do qual copiar dados.
• Retorna: <Buffer>

Copia os dados do buffer passado para uma nova instância de Buffer.

ESM

import { Buffer } from 'node:buffer'

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

buf1[0] = 0x61

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

CJS

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

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

buf1[0] = 0x61

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

Um TypeError será lançado se buffer não for um Buffer ou outro tipo apropriado para variantes de Buffer.from().

Método estático: Buffer.from(object[, offsetOrEncoding[, length]])

Adicionado em: v8.2.0

• object <Object> Um objeto com suporte para Symbol.toPrimitive ou valueOf().
• offsetOrEncoding <integer> | <string> Um deslocamento de byte ou codificação.
• length <integer> Um comprimento.
• Retorna: <Buffer>

Para objetos cuja função valueOf() retorna um valor não estritamente igual a object, retorna Buffer.from(object.valueOf(), offsetOrEncoding, length).

ESM

import { Buffer } from 'node:buffer'

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

CJS

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

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

Para objetos que suportam Symbol.toPrimitive, retorna Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding).

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

Um TypeError será lançado se object não tiver os métodos mencionados ou não for de outro tipo apropriado para variantes de Buffer.from().

Método estático: Buffer.from(string[, encoding])

Adicionado em: v5.10.0

• string <string> Uma string para codificar.
• encoding <string> A codificação de string. Padrão: 'utf8'.
• Retorna: <Buffer>

Cria um novo Buffer contendo string. O parâmetro encoding identifica a codificação de caracteres a ser usada ao converter string em bytes.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

Um TypeError será lançado se string não for uma string ou outro tipo apropriado para as variantes de Buffer.from().

Buffer.from(string) também pode usar o pool Buffer interno como Buffer.allocUnsafe() faz.

Método estático: Buffer.isBuffer(obj)

Adicionado em: v0.1.101

• obj <Object>
• Retorna: <boolean>

Retorna true se obj for um Buffer, false caso contrário.

ESM

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

CJS

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étodo estático: Buffer.isEncoding(encoding)

Adicionado em: v0.9.1

• encoding <string> Um nome de codificação de caracteres para verificar.
• Retorna: <boolean>

Retorna true se encoding for o nome de uma codificação de caracteres suportada ou false caso contrário.

ESM

import { Buffer } from 'node:buffer'

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

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

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

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

CJS

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

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

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

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

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

Propriedade da classe: Buffer.poolSize

Adicionado em: v0.11.3

• <integer> Padrão: 8192

Este é o tamanho (em bytes) de instâncias Buffer internas pré-alocadas usadas para agrupamento. Esse valor pode ser modificado.

buf[index]

• index <integer>

O operador de índice [index] pode ser usado para obter e definir o octeto na posição index em buf. Os valores referem-se a bytes individuais, portanto, o intervalo de valores legal é entre 0x00 e 0xFF (hex) ou 0 e 255 (decimal).

Este operador é herdado de Uint8Array, então seu comportamento em acesso fora dos limites é o mesmo que Uint8Array. Em outras palavras, buf[index] retorna undefined quando index é negativo ou maior ou igual a buf.length, e buf[index] = value não modifica o buffer se index for negativo ou \>= buf.length.

ESM

import { Buffer } from 'node:buffer'

// Copia uma string ASCII para um `Buffer` um byte de cada vez.
// (Isso só funciona para strings apenas ASCII. Em geral, deve-se usar
// `Buffer.from()` para realizar essa conversão.)

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'))
// Imprime: Node.js

CJS

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

// Copia uma string ASCII para um `Buffer` um byte de cada vez.
// (Isso só funciona para strings apenas ASCII. Em geral, deve-se usar
// `Buffer.from()` para realizar essa conversão.)

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'))
// Imprime: Node.js

buf.buffer

• <ArrayBuffer> O objeto ArrayBuffer subjacente com base no qual este objeto Buffer é criado.

Não é garantido que este ArrayBuffer corresponda exatamente ao Buffer original. Consulte as notas em buf.byteOffset para obter detalhes.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.byteOffset

• <integer> O byteOffset do objeto ArrayBuffer subjacente do Buffer.

Ao definir byteOffset em Buffer.from(ArrayBuffer, byteOffset, length) ou, às vezes, ao alocar um Buffer menor que Buffer.poolSize, o buffer não começa com um deslocamento zero no ArrayBuffer subjacente.

Isso pode causar problemas ao acessar o ArrayBuffer subjacente diretamente usando buf.buffer, pois outras partes do ArrayBuffer podem não estar relacionadas ao próprio objeto Buffer.

Um problema comum ao criar um objeto TypedArray que compartilha sua memória com um Buffer é que, nesse caso, é necessário especificar o byteOffset corretamente:

ESM

import { Buffer } from 'node:buffer'

// Cria um buffer menor que `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// Ao converter o Buffer Node.js em um Int8Array, use o byteOffset
// para se referir apenas à parte de `nodeBuffer.buffer` que contém a memória
// para `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

CJS

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

// Cria um buffer menor que `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// Ao converter o Buffer Node.js em um Int8Array, use o byteOffset
// para se referir apenas à parte de `nodeBuffer.buffer` que contém a memória
// para `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

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

[Histórico]

Versão	Mudanças
v8.0.0	O parâmetro target agora pode ser um Uint8Array.
v5.11.0	Parâmetros adicionais para especificar deslocamentos são suportados agora.
v0.11.13	Adicionado em: v0.11.13

• target <Buffer> | <Uint8Array> Um Buffer ou Uint8Array com o qual comparar buf.
• targetStart <integer> O deslocamento dentro de target em que iniciar a comparação. Padrão: 0.
• targetEnd <integer> O deslocamento dentro de target em que terminar a comparação (não inclusivo). Padrão: target.length.
• sourceStart <integer> O deslocamento dentro de buf em que iniciar a comparação. Padrão: 0.
• sourceEnd <integer> O deslocamento dentro de buf em que terminar a comparação (não inclusivo). Padrão: buf.length.
• Retorna: <integer>

Compara buf com target e retorna um número indicando se buf vem antes, depois ou é igual a target na ordem de classificação. A comparação é baseada na sequência real de bytes em cada Buffer.

• 0 é retornado se target for igual a buf
• 1 é retornado se target deve vir antes de buf quando classificado.
• -1 é retornado se target deve vir depois de buf quando classificado.

ESM

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))
// Imprime: 0
console.log(buf1.compare(buf2))
// Imprime: -1
console.log(buf1.compare(buf3))
// Imprime: -1
console.log(buf2.compare(buf1))
// Imprime: 1
console.log(buf2.compare(buf3))
// Imprime: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Imprime: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (Este resultado é igual a: [buf1, buf3, buf2].)

CJS

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))
// Imprime: 0
console.log(buf1.compare(buf2))
// Imprime: -1
console.log(buf1.compare(buf3))
// Imprime: -1
console.log(buf2.compare(buf1))
// Imprime: 1
console.log(buf2.compare(buf3))
// Imprime: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Imprime: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (Este resultado é igual a: [buf1, buf3, buf2].)

Os argumentos opcionais targetStart, targetEnd, sourceStart e sourceEnd podem ser usados para limitar a comparação a intervalos específicos dentro de target e buf, respectivamente.

ESM

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))
// Imprime: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Imprime: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Imprime: 1

CJS

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))
// Imprime: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Imprime: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Imprime: 1

ERR_OUT_OF_RANGE é lançado se targetStart < 0, sourceStart < 0, targetEnd > target.byteLength ou sourceEnd > source.byteLength.

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

Adicionado em: v0.1.90

• target <Buffer> | <Uint8Array> Um Buffer ou Uint8Array para copiar.
• targetStart <integer> O deslocamento dentro de target no qual começar a escrever. Padrão: 0.
• sourceStart <integer> O deslocamento dentro de buf de onde começar a copiar. Padrão: 0.
• sourceEnd <integer> O deslocamento dentro de buf em que parar de copiar (não inclusivo). Padrão: buf.length.
• Retorna: <integer> O número de bytes copiados.

Copia dados de uma região de buf para uma região em target, mesmo que a região de memória de target se sobreponha a buf.

TypedArray.prototype.set() realiza a mesma operação e está disponível para todos os TypedArrays, incluindo Buffers do Node.js, embora receba argumentos de função diferentes.

ESM

import { Buffer } from 'node:buffer'

// Cria duas instâncias de `Buffer`.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

for (let i = 0; i < 26; i++) {
  // 97 é o valor ASCII decimal para 'a'.
  buf1[i] = i + 97
}

// Copia os bytes 16 a 19 de `buf1` para `buf2`, começando no byte 8 de `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Isto é equivalente a:
// buf2.set(buf1.subarray(16, 20), 8);

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

CJS

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

// Cria duas instâncias de `Buffer`.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

for (let i = 0; i < 26; i++) {
  // 97 é o valor ASCII decimal para 'a'.
  buf1[i] = i + 97
}

// Copia os bytes 16 a 19 de `buf1` para `buf2`, começando no byte 8 de `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Isto é equivalente a:
// buf2.set(buf1.subarray(16, 20), 8);

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

ESM

import { Buffer } from 'node:buffer'

// Cria um `Buffer` e copia dados de uma região para uma região sobreposta
// dentro do mesmo `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 é o valor ASCII decimal para 'a'.
  buf[i] = i + 97
}

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

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

CJS

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

// Cria um `Buffer` e copia dados de uma região para uma região sobreposta
// dentro do mesmo `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 é o valor ASCII decimal para 'a'.
  buf[i] = i + 97
}

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

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

buf.entries()

Adicionado em: v1.1.0

• Retorna: <Iterator>

Cria e retorna um iterador de pares [index, byte] do conteúdo de buf.

ESM

import { Buffer } from 'node:buffer'

// Registra todo o conteúdo de um `Buffer`.

const buf = Buffer.from('buffer')

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

CJS

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

// Registra todo o conteúdo de um `Buffer`.

const buf = Buffer.from('buffer')

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

buf.equals(otherBuffer)

[Histórico]

Versão	Alterações
v8.0.0	Os argumentos agora podem ser Uint8Arrays.
v0.11.13	Adicionado em: v0.11.13

• otherBuffer <Buffer> | <Uint8Array> Um Buffer ou Uint8Array com o qual comparar buf.
• Retorna: <boolean>

Retorna true se ambos buf e otherBuffer tiverem exatamente os mesmos bytes, false caso contrário. Equivalente a buf.compare(otherBuffer) === 0.

ESM

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))
// Imprime: true
console.log(buf1.equals(buf3))
// Imprime: false

CJS

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))
// Imprime: true
console.log(buf1.equals(buf3))
// Imprime: false

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

[Histórico]

Versão	Mudanças
v11.0.0	Lança ERR_OUT_OF_RANGE em vez de ERR_INDEX_OUT_OF_RANGE.
v10.0.0	Valores end negativos lançam um erro ERR_INDEX_OUT_OF_RANGE.
v10.0.0	Tentar preencher um buffer de comprimento não zero com um buffer de comprimento zero aciona uma exceção lançada.
v10.0.0	Especificar uma string inválida para value aciona uma exceção lançada.
v5.7.0	O parâmetro encoding é suportado agora.
v0.5.0	Adicionado em: v0.5.0

• value <string> | <Buffer> | <Uint8Array> | <integer> O valor com o qual preencher buf. Um valor vazio (string, Uint8Array, Buffer) é coagido para 0.
• offset <integer> Número de bytes a serem ignorados antes de começar a preencher buf. Padrão: 0.
• end <integer> Onde parar de preencher buf (não inclusivo). Padrão: buf.length.
• encoding <string> A codificação para value se value for uma string. Padrão: 'utf8'.
• Retorna: <Buffer> Uma referência para buf.

Preenche buf com o value especificado. Se offset e end não forem fornecidos, todo o buf será preenchido:

ESM

import { Buffer } from 'node:buffer'

// Preenche um `Buffer` com o caractere ASCII 'h'.

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

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

// Preenche um buffer com string vazia
const c = Buffer.allocUnsafe(5).fill('')

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

CJS

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

// Preenche um `Buffer` com o caractere ASCII 'h'.

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

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

// Preenche um buffer com string vazia
const c = Buffer.allocUnsafe(5).fill('')

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

value é coagido para um valor uint32 se não for uma string, Buffer ou inteiro. Se o inteiro resultante for maior que 255 (decimal), buf será preenchido com value & 255.

Se a escrita final de uma operação fill() cair em um caractere multibyte, apenas os bytes desse caractere que cabem em buf são escritos:

ESM

import { Buffer } from 'node:buffer'

// Preenche um `Buffer` com um caractere que ocupa dois bytes em UTF-8.

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

CJS

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

// Preenche um `Buffer` com um caractere que ocupa dois bytes em UTF-8.

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

Se value contiver caracteres inválidos, ele será truncado; se nenhum dado de preenchimento válido permanecer, uma exceção será lançada:

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(5)

console.log(buf.fill('a'))
// Imprime: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Imprime: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// Lança uma exceção.

CJS

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

const buf = Buffer.allocUnsafe(5)

console.log(buf.fill('a'))
// Imprime: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Imprime: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// Lança uma exceção.

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

Adicionado em: v5.3.0

• value <string> | <Buffer> | <Uint8Array> | <integer> O que procurar.
• byteOffset <integer> Onde começar a pesquisa em buf. Se negativo, o deslocamento é calculado a partir do final de buf. Padrão: 0.
• encoding <string> Se value for uma string, esta é sua codificação. Padrão: 'utf8'.
• Retorna: <boolean> true se value foi encontrado em buf, false caso contrário.

Equivalente a buf.indexOf() !== -1.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.includes('this'))
// Imprime: true
console.log(buf.includes('is'))
// Imprime: true
console.log(buf.includes(Buffer.from('a buffer')))
// Imprime: true
console.log(buf.includes(97))
// Imprime: true (97 é o valor ASCII decimal para 'a')
console.log(buf.includes(Buffer.from('a buffer example')))
// Imprime: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Imprime: true
console.log(buf.includes('this', 4))
// Imprime: false

CJS

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

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

console.log(buf.includes('this'))
// Imprime: true
console.log(buf.includes('is'))
// Imprime: true
console.log(buf.includes(Buffer.from('a buffer')))
// Imprime: true
console.log(buf.includes(97))
// Imprime: true (97 é o valor ASCII decimal para 'a')
console.log(buf.includes(Buffer.from('a buffer example')))
// Imprime: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Imprime: true
console.log(buf.includes('this', 4))
// Imprime: false

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

[Histórico]

Versão	Mudanças
v8.0.0	O value agora pode ser um Uint8Array.
v5.7.0, v4.4.0	Quando encoding é passado, o parâmetro byteOffset não é mais obrigatório.
v1.5.0	Adicionado em: v1.5.0

• value <string> | <Buffer> | <Uint8Array> | <integer> O que procurar.
• byteOffset <integer> Onde começar a procurar em buf. Se negativo, o deslocamento é calculado a partir do final de buf. Padrão: 0.
• encoding <string> Se value for uma string, esta é a codificação usada para determinar a representação binária da string que será procurada em buf. Padrão: 'utf8'.
• Retorna: <integer> O índice da primeira ocorrência de value em buf, ou -1 se buf não contiver value.

Se value for:

• uma string, value é interpretado de acordo com a codificação de caracteres em encoding.
• um Buffer ou Uint8Array, value será usado em sua totalidade. Para comparar um Buffer parcial, use buf.subarray.
• um número, value será interpretado como um valor inteiro de 8 bits não assinado entre 0 e 255.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.indexOf('this'))
// Imprime: 0
console.log(buf.indexOf('is'))
// Imprime: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Imprime: 8
console.log(buf.indexOf(97))
// Imprime: 8 (97 é o valor ASCII decimal para 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Imprime: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Imprime: 8

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

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

CJS

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

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

console.log(buf.indexOf('this'))
// Imprime: 0
console.log(buf.indexOf('is'))
// Imprime: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Imprime: 8
console.log(buf.indexOf(97))
// Imprime: 8 (97 é o valor ASCII decimal para 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Imprime: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Imprime: 8

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

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

Se value não for uma string, número ou Buffer, este método lançará um TypeError. Se value for um número, ele será forçado a um valor de byte válido, um inteiro entre 0 e 255.

Se byteOffset não for um número, ele será forçado a um número. Se o resultado da coerção for NaN ou 0, todo o buffer será pesquisado. Esse comportamento corresponde a String.prototype.indexOf().

ESM

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Passando um valor que é um número, mas não um byte válido.
// Imprime: 2, equivalente a procurar por 99 ou 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Passando um byteOffset que é forçado para NaN ou 0.
// Imprime: 1, procurando em todo o buffer.
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))

CJS

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

const b = Buffer.from('abcdef')

// Passando um valor que é um número, mas não um byte válido.
// Imprime: 2, equivalente a procurar por 99 ou 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Passando um byteOffset que é forçado para NaN ou 0.
// Imprime: 1, procurando em todo o buffer.
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))

Se value for uma string vazia ou Buffer vazio e byteOffset for menor que buf.length, byteOffset será retornado. Se value estiver vazio e byteOffset for pelo menos buf.length, buf.length será retornado.

buf.keys()

Adicionado em: v1.1.0

• Retorna: <Iterator>

Cria e retorna um iterador de chaves (índices) de buf.

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

for (const key of buf.keys()) {
  console.log(key)
}
// Imprime:
//   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)
}
// Imprime:
//   0
//   1
//   2
//   3
//   4
//   5

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

[Histórico]

Versão	Mudanças
v8.0.0	O value agora pode ser um Uint8Array.
v6.0.0	Adicionado em: v6.0.0

• value <string> | <Buffer> | <Uint8Array> | <integer> O que procurar.
• byteOffset <integer> Onde começar a procurar em buf. Se for negativo, o deslocamento é calculado a partir do final de buf. Padrão: buf.length - 1.
• encoding <string> Se value for uma string, esta é a codificação usada para determinar a representação binária da string que será procurada em buf. Padrão: 'utf8'.
• Retorna: <integer> O índice da última ocorrência de value em buf, ou -1 se buf não contiver value.

Idêntico a buf.indexOf(), exceto que a última ocorrência de value é encontrada em vez da primeira ocorrência.

import { Buffer } from 'node:buffer'

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

console.log(buf.lastIndexOf('this'))
// Imprime: 0
console.log(buf.lastIndexOf('buffer'))
// Imprime: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// Imprime: 17
console.log(buf.lastIndexOf(97))
// Imprime: 15 (97 é o valor ASCII decimal para 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// Imprime: -1
console.log(buf.lastIndexOf('buffer', 5))
// Imprime: 5
console.log(buf.lastIndexOf('buffer', 4))
// Imprime: -1

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

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

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

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

console.log(buf.lastIndexOf('this'))
// Imprime: 0
console.log(buf.lastIndexOf('buffer'))
// Imprime: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// Imprime: 17
console.log(buf.lastIndexOf(97))
// Imprime: 15 (97 é o valor ASCII decimal para 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// Imprime: -1
console.log(buf.lastIndexOf('buffer', 5))
// Imprime: 5
console.log(buf.lastIndexOf('buffer', 4))
// Imprime: -1

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

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

Se value não for uma string, número ou Buffer, este método lançará um TypeError. Se value for um número, ele será coagido a um valor de byte válido, um inteiro entre 0 e 255.

Se byteOffset não for um número, ele será coagido a um número. Quaisquer argumentos que se convertam em NaN, como {} ou undefined, procurarão em todo o buffer. Este comportamento corresponde a String.prototype.lastIndexOf().

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Passando um valor que é um número, mas não um byte válido.
// Imprime: 2, equivalente a procurar por 99 ou 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Passando um byteOffset que se converte em NaN.
// Imprime: 1, procurando em todo o buffer.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Passando um byteOffset que se converte em 0.
// Imprime: -1, equivalente a passar 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

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

const b = Buffer.from('abcdef')

// Passando um valor que é um número, mas não um byte válido.
// Imprime: 2, equivalente a procurar por 99 ou 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Passando um byteOffset que se converte em NaN.
// Imprime: 1, procurando em todo o buffer.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Passando um byteOffset que se converte em 0.
// Imprime: -1, equivalente a passar 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

Se value for uma string vazia ou um Buffer vazio, byteOffset será retornado.

buf.length

Adicionado em: v0.1.90

• <integer>

Retorna o número de bytes em buf.

ESM

import { Buffer } from 'node:buffer'

// Cria um `Buffer` e escreve uma string mais curta nele usando UTF-8.

const buf = Buffer.alloc(1234)

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

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

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

CJS

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

// Cria um `Buffer` e escreve uma string mais curta nele usando UTF-8.

const buf = Buffer.alloc(1234)

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

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

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

buf.parent

Obsoleto desde: v8.0.0

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto: Use buf.buffer em vez disso.

A propriedade buf.parent é um alias obsoleto para buf.buffer.

buf.readBigInt64BE([offset])

Adicionado em: v12.0.0, v10.20.0

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer: 0 <= offset <= buf.length - 8. Padrão: 0.
• Retorna: <bigint>

Lê um inteiro de 64 bits com sinal, big-endian de buf no offset especificado.

Inteiros lidos de um Buffer são interpretados como valores com sinal de complemento de dois.

buf.readBigInt64LE([offset])

Adicionado em: v12.0.0, v10.20.0

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer: 0 <= offset <= buf.length - 8. Padrão: 0.
• Retorna: <bigint>

Lê um inteiro de 64 bits com sinal, little-endian de buf no offset especificado.

Inteiros lidos de um Buffer são interpretados como valores com sinal de complemento de dois.

buf.readBigUInt64BE([offset])

[Histórico]

Versão	Mudanças
v14.10.0, v12.19.0	Esta função também está disponível como buf.readBigUint64BE().
v12.0.0, v10.20.0	Adicionado em: v12.0.0, v10.20.0

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer: 0 <= offset <= buf.length - 8. Padrão: 0.
• Retorna: <bigint>

Lê um inteiro não assinado de 64 bits big-endian de buf no offset especificado.

Esta função também está disponível sob o alias readBigUint64BE.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readBigUInt64LE([offset])

[Histórico]

Versão	Mudanças
v14.10.0, v12.19.0	Esta função também está disponível como buf.readBigUint64LE().
v12.0.0, v10.20.0	Adicionado em: v12.0.0, v10.20.0

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer: 0 <= offset <= buf.length - 8. Padrão: 0.
• Retorna: <bigint>

Lê um inteiro não assinado de 64 bits little-endian de buf no offset especificado.

Esta função também está disponível sob o alias readBigUint64LE.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readDoubleBE([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e sem coerção implícita do deslocamento para uint32 agora.
v0.11.15	Adicionado em: v0.11.15

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 \<= offset \<= buf.length - 8. Padrão: 0.
• Retorna: <number>

Lê um double de 64 bits big-endian de buf no offset especificado.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readDoubleLE([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e sem coerção implícita do deslocamento para uint32 agora.
v0.11.15	Adicionado em: v0.11.15

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 \<= offset \<= buf.length - 8. Padrão: 0.
• Retorna: <number>

Lê um double de 64 bits little-endian de buf no offset especificado.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readDoubleLE(0))
// Imprime: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readDoubleLE(0))
// Imprime: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Lança ERR_OUT_OF_RANGE.

buf.readFloatBE([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.11.15	Adicionado em: v0.11.15

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 <= offset <= buf.length - 4. Padrão: 0.
• Retorna: <number>

Lê um float de 32 bits, big-endian de buf no offset especificado.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readFloatLE([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.11.15	Adicionado em: v0.11.15

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 <= offset <= buf.length - 4. Padrão: 0.
• Retorna: <number>

Lê um float de 32 bits, little-endian de buf no offset especificado.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readFloatLE(0))
// Imprime: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readFloatLE(0))
// Imprime: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Lança ERR_OUT_OF_RANGE.

buf.readInt8([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.0	Adicionado em: v0.5.0

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 <= offset <= buf.length - 1. Padrão: 0.
• Retorna: <integer>

Lê um inteiro de 8 bits com sinal de buf no offset especificado.

Inteiros lidos de um Buffer são interpretados como valores de complemento de dois com sinal.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt8(0))
// Imprime: -1
console.log(buf.readInt8(1))
// Imprime: 5
console.log(buf.readInt8(2))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readInt8(0))
// Imprime: -1
console.log(buf.readInt8(1))
// Imprime: 5
console.log(buf.readInt8(2))
// Lança ERR_OUT_OF_RANGE.

buf.readInt16BE([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 <= offset <= buf.length - 2. Padrão: 0.
• Retorna: <integer>

Lê um inteiro de 16 bits com sinal e big-endian de buf no offset especificado.

Inteiros lidos de um Buffer são interpretados como valores de complemento de dois com sinal.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readInt16LE([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer 0 \<= offset \<= buf.length - 2. Padrão: 0.
• Retorna: <integer>

Lê um inteiro de 16 bits com sinal, little-endian, de buf no offset especificado.

Inteiros lidos de um Buffer são interpretados como valores com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt16LE(0))
// Imprime: 1280
console.log(buf.readInt16LE(1))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readInt16LE(0))
// Imprime: 1280
console.log(buf.readInt16LE(1))
// Lança ERR_OUT_OF_RANGE.

buf.readInt32BE([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer 0 \<= offset \<= buf.length - 4. Padrão: 0.
• Retorna: <integer>

Lê um inteiro de 32 bits com sinal, big-endian, de buf no offset especificado.

Inteiros lidos de um Buffer são interpretados como valores com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readInt32LE([offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 \<= offset \<= buf.length - 4. Padrão: 0.
• Retorna: <integer>

Lê um inteiro de 32 bits com sinal, little-endian, de buf no offset especificado.

Inteiros lidos de um Buffer são interpretados como valores com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt32LE(0))
// Imprime: 83886080
console.log(buf.readInt32LE(1))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readInt32LE(0))
// Imprime: 83886080
console.log(buf.readInt32LE(1))
// Lança ERR_OUT_OF_RANGE.

buf.readIntBE(offset, byteLength)

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento e byteLength para uint32.
v0.11.15	Adicionado em: v0.11.15

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes a serem lidos. Deve satisfazer 0 < byteLength <= 6.
• Retorna: <integer>

Lê byteLength número de bytes de buf no offset especificado e interpreta o resultado como um valor com sinal big-endian de complemento de dois, suportando até 48 bits de precisão.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readIntBE(0, 6).toString(16))
// Imprime: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// Lança ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readIntBE(0, 6).toString(16))
// Imprime: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// Lança ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Lança ERR_OUT_OF_RANGE.

buf.readIntLE(offset, byteLength)

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento e byteLength para uint32.
v0.11.15	Adicionado em: v0.11.15

• offset <inteiro> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 \<= offset \<= buf.length - byteLength.
• byteLength <inteiro> Número de bytes a serem lidos. Deve satisfazer 0 \< byteLength \<= 6.
• Retorna: <inteiro>

Lê o número de bytes byteLength de buf no offset especificado e interpreta o resultado como um valor de complemento de dois com sinal little-endian, suportando até 48 bits de precisão.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readUInt8([offset])

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.readUint8().
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.0	Adicionado em: v0.5.0

• offset <inteiro> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 \<= offset \<= buf.length - 1. Padrão: 0.
• Retorna: <inteiro>

Lê um inteiro não assinado de 8 bits de buf no offset especificado.

Esta função também está disponível sob o alias readUint8.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt8(0))
// Imprime: 1
console.log(buf.readUInt8(1))
// Imprime: 254
console.log(buf.readUInt8(2))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readUInt8(0))
// Imprime: 1
console.log(buf.readUInt8(1))
// Imprime: 254
console.log(buf.readUInt8(2))
// Lança ERR_OUT_OF_RANGE.

buf.readUInt16BE([offset])

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.readUint16BE().
v10.0.0	Removido noAssert e nenhuma coerção implícita do offset para uint32.
v0.5.5	Adicionado em: v0.5.5

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer 0 <= offset <= buf.length - 2. Padrão: 0.
• Retorna: <integer>

Lê um inteiro de 16 bits não assinado, big-endian, de buf no offset especificado.

Essa função também está disponível sob o alias readUint16BE.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readUInt16LE([offset])

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.readUint16LE().
v10.0.0	Removido noAssert e nenhuma coerção implícita do offset para uint32.
v0.5.5	Adicionado em: v0.5.5

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer 0 <= offset <= buf.length - 2. Padrão: 0.
• Retorna: <integer>

Lê um inteiro de 16 bits não assinado, little-endian, de buf no offset especificado.

Essa função também está disponível sob o alias readUint16LE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt16LE(0).toString(16))
// Imprime: 3412
console.log(buf.readUInt16LE(1).toString(16))
// Imprime: 5634
console.log(buf.readUInt16LE(2).toString(16))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readUInt16LE(0).toString(16))
// Imprime: 3412
console.log(buf.readUInt16LE(1).toString(16))
// Imprime: 5634
console.log(buf.readUInt16LE(2).toString(16))
// Lança ERR_OUT_OF_RANGE.

buf.readUInt32BE([offset])

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.readUint32BE().
v10.0.0	Removido noAssert e sem coerção implícita do deslocamento para uint32 mais.
v0.5.5	Adicionado em: v0.5.5

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 \<= offset \<= buf.length - 4. Padrão: 0.
• Retorna: <integer>

Lê um inteiro não assinado de 32 bits big-endian de buf no offset especificado.

Esta função também está disponível sob o alias readUint32BE.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

buf.readUInt32LE([offset])

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.readUint32LE().
v10.0.0	Removido noAssert e sem coerção implícita do deslocamento para uint32 mais.
v0.5.5	Adicionado em: v0.5.5

• offset <integer> Número de bytes a serem ignorados antes de começar a leitura. Deve satisfazer 0 \<= offset \<= buf.length - 4. Padrão: 0.
• Retorna: <integer>

Lê um inteiro não assinado de 32 bits little-endian de buf no offset especificado.

Esta função também está disponível sob o alias readUint32LE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt32LE(0).toString(16))
// Imprime: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readUInt32LE(0).toString(16))
// Imprime: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Lança ERR_OUT_OF_RANGE.

buf.readUIntBE(offset, byteLength)

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.readUintBE().
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento e byteLength para uint32.
v0.11.15	Adicionado em: v0.11.15

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes a serem lidos. Deve satisfazer 0 < byteLength <= 6.
• Retorna: <integer>

Lê byteLength número de bytes de buf no offset especificado e interpreta o resultado como um inteiro não assinado big-endian suportando até 48 bits de precisão.

Esta função também está disponível sob o alias readUintBE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUIntBE(0, 6).toString(16))
// Imprime: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// Lança ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readUIntBE(0, 6).toString(16))
// Imprime: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// Lança ERR_OUT_OF_RANGE.

buf.readUIntLE(offset, byteLength)

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.readUintLE().
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento e byteLength para uint32.
v0.11.15	Adicionado em: v0.11.15

• offset <integer> Número de bytes a serem ignorados antes de começar a ler. Deve satisfazer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes a serem lidos. Deve satisfazer 0 < byteLength <= 6.
• Retorna: <integer>

Lê byteLength número de bytes de buf no offset especificado e interpreta o resultado como um inteiro não assinado, little-endian, suportando até 48 bits de precisão.

Esta função também está disponível sob o alias readUintLE.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

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

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

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

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

Adicionado em: v3.0.0

• start <integer> Onde o novo Buffer vai começar. Padrão: 0.
• end <integer> Onde o novo Buffer vai terminar (não inclusivo). Padrão: buf.length.
• Retorna: <Buffer>

Retorna um novo Buffer que referencia a mesma memória que o original, mas com deslocamento e recorte pelos índices start e end.

Especificar end maior que buf.length retornará o mesmo resultado que end igual a buf.length.

Este método é herdado de TypedArray.prototype.subarray().

Modificar a nova fatia Buffer modificará a memória no Buffer original porque a memória alocada dos dois objetos se sobrepõe.

ESM

import { Buffer } from 'node:buffer'

// Crie um `Buffer` com o alfabeto ASCII, pegue uma fatia e modifique um byte
// do `Buffer` original.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 é o valor decimal ASCII para 'a'.
  buf1[i] = i + 97
}

const buf2 = buf1.subarray(0, 3)

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

buf1[0] = 33

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

CJS

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

// Crie um `Buffer` com o alfabeto ASCII, pegue uma fatia e modifique um byte
// do `Buffer` original.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 é o valor decimal ASCII para 'a'.
  buf1[i] = i + 97
}

const buf2 = buf1.subarray(0, 3)

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

buf1[0] = 33

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

Especificar índices negativos faz com que a fatia seja gerada em relação ao final de buf em vez do início.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

console.log(buf.subarray(-6, -1).toString())
// Imprime: buffe
// (Equivalente a buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString())
// Imprime: buff
// (Equivalente a buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString())
// Imprime: uff
// (Equivalente a buf.subarray(1, 4).)

CJS

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

const buf = Buffer.from('buffer')

console.log(buf.subarray(-6, -1).toString())
// Imprime: buffe
// (Equivalente a buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString())
// Imprime: buff
// (Equivalente a buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString())
// Imprime: uff
// (Equivalente a buf.subarray(1, 4).)

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

[Histórico]

Versão	Mudanças
v17.5.0, v16.15.0	O método buf.slice() foi descontinuado.
v7.0.0	Todos os deslocamentos agora são convertidos em inteiros antes de fazer quaisquer cálculos com eles.
v7.1.0, v6.9.2	A conversão dos deslocamentos para inteiros agora lida corretamente com valores fora do intervalo de inteiros de 32 bits.
v0.3.0	Adicionado em: v0.3.0

• start <integer> Onde o novo Buffer começará. Padrão: 0.
• end <integer> Onde o novo Buffer terminará (não inclusivo). Padrão: buf.length.
• Retorna: <Buffer>

[Estável: 0 - Descontinuado]

Estável: 0 Estabilidade: 0 - Descontinuado: Use buf.subarray em vez disso.

Retorna um novo Buffer que referencia a mesma memória que o original, mas deslocado e cortado pelos índices start e end.

Este método não é compatível com Uint8Array.prototype.slice(), que é uma superclasse de Buffer. Para copiar o slice, use Uint8Array.prototype.slice().

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

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

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

// Com buf.slice(), o buffer original é modificado.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Imprime: cuffer
console.log(buf.toString())
// Também imprime: cuffer (!)

CJS

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

const buf = Buffer.from('buffer')

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

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

// Com buf.slice(), o buffer original é modificado.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Imprime: cuffer
console.log(buf.toString())
// Também imprime: cuffer (!)

buf.swap16()

Adicionado em: v5.10.0

• Retorna: <Buffer> Uma referência para buf.

Interpreta buf como um array de inteiros não assinados de 16 bits e troca a ordem dos bytes in-place. Lança ERR_INVALID_BUFFER_SIZE se buf.length não for um múltiplo de 2.

ESM

import { Buffer } from 'node:buffer'

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

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

buf1.swap16()

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

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

buf2.swap16()
// Lança ERR_INVALID_BUFFER_SIZE.

CJS

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

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

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

buf1.swap16()

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

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

buf2.swap16()
// Lança ERR_INVALID_BUFFER_SIZE.

Um uso conveniente de buf.swap16() é para realizar uma conversão rápida in-place entre UTF-16 little-endian e UTF-16 big-endian:

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // Converte para texto UTF-16 big-endian.

CJS

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

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // Converte para texto UTF-16 big-endian.

buf.swap32()

Adicionado em: v5.10.0

• Retorna: <Buffer> Uma referência para buf.

Interpreta buf como um array de inteiros não assinados de 32 bits e troca a ordem dos bytes in-place. Lança ERR_INVALID_BUFFER_SIZE se buf.length não for um múltiplo de 4.

ESM

import { Buffer } from 'node:buffer'

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

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

buf1.swap32()

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

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

buf2.swap32()
// Lança ERR_INVALID_BUFFER_SIZE.

CJS

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

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

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

buf1.swap32()

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

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

buf2.swap32()
// Lança ERR_INVALID_BUFFER_SIZE.

buf.swap64()

Adicionado em: v6.3.0

• Retorna: <Buffer> Uma referência para buf.

Interpreta buf como uma matriz de números de 64 bits e troca a ordem dos bytes in-place. Lança ERR_INVALID_BUFFER_SIZE se buf.length não for um múltiplo de 8.

ESM

import { Buffer } from 'node:buffer'

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

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

buf1.swap64()

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

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

buf2.swap64()
// Lança ERR_INVALID_BUFFER_SIZE.

CJS

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

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

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

buf1.swap64()

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

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

buf2.swap64()
// Lança ERR_INVALID_BUFFER_SIZE.

buf.toJSON()

Adicionado em: v0.9.2

• Retorna: <Object>

Retorna uma representação JSON de buf. JSON.stringify() chama implicitamente esta função ao transformar uma instância de Buffer em string.

Buffer.from() aceita objetos no formato retornado por este método. Em particular, Buffer.from(buf.toJSON()) funciona como Buffer.from(buf).

ESM

import { Buffer } from 'node:buffer'

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

console.log(json)
// Imprime: {"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)
// Imprime: <Buffer 01 02 03 04 05>

CJS

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

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

console.log(json)
// Imprime: {"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)
// Imprime: <Buffer 01 02 03 04 05>

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

Adicionado em: v0.1.90

• encoding <string> A codificação de caracteres a ser usada. Padrão: 'utf8'.
• start <integer> O deslocamento de bytes para iniciar a decodificação. Padrão: 0.
• end <integer> O deslocamento de bytes para parar a decodificação (não inclusivo). Padrão: buf.length.
• Retorna: <string>

Decodifica buf para uma string de acordo com a codificação de caracteres especificada em encoding. start e end podem ser passados para decodificar apenas um subconjunto de buf.

Se encoding for 'utf8' e uma sequência de bytes na entrada não for UTF-8 válida, cada byte inválido é substituído pelo caractere de substituição U+FFFD.

O comprimento máximo de uma instância de string (em unidades de código UTF-16) está disponível como buffer.constants.MAX_STRING_LENGTH.

ESM

import { Buffer } from 'node:buffer'

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 é o valor ASCII decimal para 'a'.
  buf1[i] = i + 97
}

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

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

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

CJS

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

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 é o valor ASCII decimal para 'a'.
  buf1[i] = i + 97
}

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

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

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

buf.values()

Adicionado em: v1.1.0

• Retorna: <Iterator>

Cria e retorna um iterador para os valores de buf (bytes). Esta função é chamada automaticamente quando um Buffer é usado em uma declaração for..of.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

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

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

CJS

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

const buf = Buffer.from('buffer')

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

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

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

Adicionado em: v0.1.90

• string <string> String a ser escrita em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever string. Padrão: 0.
• length <integer> Número máximo de bytes a serem escritos (os bytes escritos não excederão buf.length - offset). Padrão: buf.length - offset.
• encoding <string> A codificação de caractere de string. Padrão: 'utf8'.
• Retorna: <integer> Número de bytes escritos.

Escreve string em buf em offset de acordo com a codificação de caractere em encoding. O parâmetro length é o número de bytes a serem escritos. Se buf não contiver espaço suficiente para acomodar a string inteira, apenas parte de string será escrita. No entanto, caracteres parcialmente codificados não serão escritos.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(256)

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

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

const buffer = Buffer.alloc(10)

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

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

CJS

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

const buf = Buffer.alloc(256)

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

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

const buffer = Buffer.alloc(10)

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

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

buf.writeBigInt64BE(valor[, deslocamento])

Adicionado em: v12.0.0, v10.20.0

• valor <bigint> Número a ser escrito em buf.
• deslocamento <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer: 0 <= deslocamento <= buf.length - 8. Padrão: 0.
• Retorna: <integer> deslocamento mais o número de bytes escritos.

Escreve valor em buf no deslocamento especificado como big-endian.

valor é interpretado e escrito como um inteiro com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64BE(0x0102030405060708n, 0)

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

CJS

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

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64BE(0x0102030405060708n, 0)

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

buf.writeBigInt64LE(valor[, deslocamento])

Adicionado em: v12.0.0, v10.20.0

• valor <bigint> Número a ser escrito em buf.
• deslocamento <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer: 0 <= deslocamento <= buf.length - 8. Padrão: 0.
• Retorna: <integer> deslocamento mais o número de bytes escritos.

Escreve valor em buf no deslocamento especificado como little-endian.

valor é interpretado e escrito como um inteiro com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64LE(0x0102030405060708n, 0)

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

CJS

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

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64LE(0x0102030405060708n, 0)

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

buf.writeBigUInt64BE(value[, offset])

[Histórico]

Versão	Alterações
v14.10.0, v12.19.0	Esta função também está disponível como buf.writeBigUint64BE().
v12.0.0, v10.20.0	Adicionado em: v12.0.0, v10.20.0

• value <bigint> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer: 0 <= offset <= buf.length - 8. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como big-endian.

Esta função também está disponível sob o alias writeBigUint64BE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64BE(0xdecafafecacefaden, 0)

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

CJS

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

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64BE(0xdecafafecacefaden, 0)

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

buf.writeBigUInt64LE(value[, offset])

[Histórico]

Versão	Alterações
v14.10.0, v12.19.0	Esta função também está disponível como buf.writeBigUint64LE().
v12.0.0, v10.20.0	Adicionado em: v12.0.0, v10.20.0

• value <bigint> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer: 0 <= offset <= buf.length - 8. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como little-endian

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64LE(0xdecafafecacefaden, 0)

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

CJS

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

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64LE(0xdecafafecacefaden, 0)

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

Esta função também está disponível sob o alias writeBigUint64LE.

buf.writeDoubleBE(value[, offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.11.15	Adicionado em: v0.11.15

• value <number> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 <= offset <= buf.length - 8. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes gravados.

Escreve value em buf no offset especificado como big-endian. O value deve ser um número JavaScript. O comportamento é indefinido quando value é algo diferente de um número JavaScript.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleBE(123.456, 0)

console.log(buf)
// Imprime: <Buffer 40 5e dd 2f 1a 9f be 77>

CJS

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

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleBE(123.456, 0)

console.log(buf)
// Imprime: <Buffer 40 5e dd 2f 1a 9f be 77>

buf.writeDoubleLE(value[, offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.11.15	Adicionado em: v0.11.15

• value <number> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 <= offset <= buf.length - 8. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes gravados.

Escreve value em buf no offset especificado como little-endian. O value deve ser um número JavaScript. O comportamento é indefinido quando value é algo diferente de um número JavaScript.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleLE(123.456, 0)

console.log(buf)
// Imprime: <Buffer 77 be 9f 1a 2f dd 5e 40>

CJS

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

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleLE(123.456, 0)

console.log(buf)
// Imprime: <Buffer 77 be 9f 1a 2f dd 5e 40>

buf.writeFloatBE(value[, offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e sem coerção implícita do offset para uint32 mais.
v0.11.15	Adicionado em: v0.11.15

• value <number> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= offset \<= buf.length - 4. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como big-endian. O comportamento é indefinido quando value é qualquer coisa além de um número JavaScript.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeFloatBE(0xcafebabe, 0)

console.log(buf)
// Imprime: <Buffer 4f 4a fe bb>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeFloatBE(0xcafebabe, 0)

console.log(buf)
// Imprime: <Buffer 4f 4a fe bb>

buf.writeFloatLE(value[, offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e sem coerção implícita do offset para uint32 mais.
v0.11.15	Adicionado em: v0.11.15

• value <number> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= offset \<= buf.length - 4. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como little-endian. O comportamento é indefinido quando value é qualquer coisa além de um número JavaScript.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeFloatLE(0xcafebabe, 0)

console.log(buf)
// Imprime: <Buffer bb fe 4a 4f>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeFloatLE(0xcafebabe, 0)

console.log(buf)
// Imprime: <Buffer bb fe 4a 4f>

buf.writeInt8(value[, offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do offset para uint32.
v0.5.0	Adicionado em: v0.5.0

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= offset \<= buf.length - 1. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado. value deve ser um inteiro de 8 bits com sinal válido. O comportamento é indefinido quando value é algo diferente de um inteiro de 8 bits com sinal.

value é interpretado e escrito como um inteiro com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)

console.log(buf)
// Imprime: <Buffer 02 fe>

CJS

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

const buf = Buffer.allocUnsafe(2)

buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)

console.log(buf)
// Imprime: <Buffer 02 fe>

buf.writeInt16BE(value[, offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removeu noAssert e não há mais coerção implícita do offset para uint32.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= offset \<= buf.length - 2. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como big-endian. O value deve ser um inteiro de 16 bits com sinal válido. O comportamento é indefinido quando value é algo diferente de um inteiro de 16 bits com sinal.

O value é interpretado e escrito como um inteiro com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt16BE(0x0102, 0)

console.log(buf)
// Imprime: <Buffer 01 02>

CJS

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

const buf = Buffer.allocUnsafe(2)

buf.writeInt16BE(0x0102, 0)

console.log(buf)
// Imprime: <Buffer 01 02>

buf.writeInt16LE(value[, offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 <= offset <= buf.length - 2. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como little-endian. O value deve ser um inteiro de 16 bits com sinal válido. O comportamento é indefinido quando value é algo diferente de um inteiro de 16 bits com sinal.

O value é interpretado e escrito como um inteiro com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt16LE(0x0304, 0)

console.log(buf)
// Imprime: <Buffer 04 03>

CJS

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

const buf = Buffer.allocUnsafe(2)

buf.writeInt16LE(0x0304, 0)

console.log(buf)
// Imprime: <Buffer 04 03>

buf.writeInt32BE(value[, offset])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 <= offset <= buf.length - 4. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como big-endian. O value deve ser um inteiro de 32 bits com sinal válido. O comportamento é indefinido quando value é algo diferente de um inteiro de 32 bits com sinal.

O value é interpretado e escrito como um inteiro com sinal de complemento de dois.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeInt32BE(0x01020304, 0)

console.log(buf)
// Imprime: <Buffer 01 02 03 04>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeInt32BE(0x01020304, 0)

console.log(buf)
// Imprime: <Buffer 01 02 03 04>

buf.writeInt32LE(valor[, deslocamento])

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e sem coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• valor <integer> Número a ser escrito em buf.
• deslocamento <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= deslocamento \<= buf.length - 4. Padrão: 0.
• Retorna: <integer> deslocamento mais o número de bytes escritos.

Escreve valor em buf no deslocamento especificado como little-endian. O valor deve ser um inteiro de 32 bits com sinal válido. O comportamento é indefinido quando valor é algo diferente de um inteiro de 32 bits com sinal.

O valor é interpretado e escrito como um inteiro com sinal em complemento de dois.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeInt32LE(0x05060708, 0)

console.log(buf)
// Imprime: <Buffer 08 07 06 05>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeInt32LE(0x05060708, 0)

console.log(buf)
// Imprime: <Buffer 08 07 06 05>

buf.writeIntBE(valor, deslocamento, byteLength)

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e sem coerção implícita do deslocamento e byteLength para uint32.
v0.11.15	Adicionado em: v0.11.15

• valor <integer> Número a ser escrito em buf.
• deslocamento <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= deslocamento \<= buf.length - byteLength.
• byteLength <integer> Número de bytes a serem escritos. Deve satisfazer 0 < byteLength <= 6.
• Retorna: <integer> deslocamento mais o número de bytes escritos.

Escreve byteLength bytes de valor em buf no deslocamento especificado como big-endian. Suporta até 48 bits de precisão. O comportamento é indefinido quando valor é algo diferente de um inteiro com sinal.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeIntBE(0x1234567890ab, 0, 6)

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

CJS

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

const buf = Buffer.allocUnsafe(6)

buf.writeIntBE(0x1234567890ab, 0, 6)

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

buf.writeIntLE(value, offset, byteLength)

[Histórico]

Versão	Mudanças
v10.0.0	Removido noAssert e sem coerção implícita do deslocamento e byteLength para uint32 mais.
v0.11.15	Adicionado em: v0.11.15

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes a serem escritos. Deve satisfazer 0 \< byteLength \<= 6.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve byteLength bytes de value em buf no offset especificado como little-endian. Suporta até 48 bits de precisão. O comportamento é indefinido quando value é algo diferente de um inteiro com sinal.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeIntLE(0x1234567890ab, 0, 6)

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

CJS

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

const buf = Buffer.allocUnsafe(6)

buf.writeIntLE(0x1234567890ab, 0, 6)

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

buf.writeUInt8(value[, offset])

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.writeUint8().
v10.0.0	Removido noAssert e sem coerção implícita do deslocamento para uint32 mais.
v0.5.0	Adicionado em: v0.5.0

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= offset \<= buf.length - 1. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado. value deve ser um inteiro não assinado de 8 bits válido. O comportamento é indefinido quando value é algo diferente de um inteiro não assinado de 8 bits.

Esta função também está disponível sob o alias writeUint8.

ESM

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)
// Imprime: <Buffer 03 04 23 42>

CJS

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)
// Imprime: <Buffer 03 04 23 42>

buf.writeUInt16BE(value[, offset])

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.writeUint16BE().
v10.0.0	Removeu noAssert e não há mais coerção implícita do offset para uint32.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 <= offset <= buf.length - 2. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como big-endian. O value deve ser um inteiro não assinado de 16 bits válido. O comportamento é indefinido quando value é qualquer coisa diferente de um inteiro não assinado de 16 bits.

Esta função também está disponível sob o alias writeUint16BE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)

console.log(buf)
// Imprime: <Buffer de ad be ef>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)

console.log(buf)
// Imprime: <Buffer de ad be ef>

buf.writeUInt16LE(value[, offset])

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.writeUint16LE().
v10.0.0	Removeu noAssert e não há mais coerção implícita do offset para uint32.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 <= offset <= buf.length - 2. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve value em buf no offset especificado como little-endian. O value deve ser um inteiro não assinado de 16 bits válido. O comportamento é indefinido quando value é qualquer coisa diferente de um inteiro não assinado de 16 bits.

Esta função também está disponível sob o alias writeUint16LE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16LE(0xdead, 0)
buf.writeUInt16LE(0xbeef, 2)

console.log(buf)
// Imprime: <Buffer ad de ef be>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16LE(0xdead, 0)
buf.writeUInt16LE(0xbeef, 2)

console.log(buf)
// Imprime: <Buffer ad de ef be>

buf.writeUInt32BE(value[, offset])

[Histórico]

Versão	Alterações
v14.9.0, v12.19.0	Esta função também está disponível como buf.writeUint32BE().
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser gravado em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a gravar. Deve satisfazer 0 <= offset <= buf.length - 4. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes gravados.

Grava value em buf no offset especificado como big-endian. O value deve ser um inteiro de 32 bits não assinado válido. O comportamento é indefinido quando value é qualquer coisa que não seja um inteiro de 32 bits não assinado.

Esta função também está disponível sob o alias writeUint32BE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32BE(0xfeedface, 0)

console.log(buf)
// Imprime: <Buffer fe ed fa ce>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32BE(0xfeedface, 0)

console.log(buf)
// Imprime: <Buffer fe ed fa ce>

buf.writeUInt32LE(value[, offset])

[Histórico]

Versão	Alterações
v14.9.0, v12.19.0	Esta função também está disponível como buf.writeUint32LE().
v10.0.0	Removeu noAssert e não há mais coerção implícita do deslocamento para uint32.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser gravado em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a gravar. Deve satisfazer 0 <= offset <= buf.length - 4. Padrão: 0.
• Retorna: <integer> offset mais o número de bytes gravados.

Grava value em buf no offset especificado como little-endian. O value deve ser um inteiro de 32 bits não assinado válido. O comportamento é indefinido quando value é qualquer coisa que não seja um inteiro de 32 bits não assinado.

Esta função também está disponível sob o alias writeUint32LE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32LE(0xfeedface, 0)

console.log(buf)
// Imprime: <Buffer ce fa ed fe>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32LE(0xfeedface, 0)

console.log(buf)
// Imprime: <Buffer ce fa ed fe>

buf.writeUIntBE(value, offset, byteLength)

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.writeUintBE().
v10.0.0	Removido noAssert e sem coerção implícita do offset e byteLength para uint32 mais.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes a serem escritos. Deve satisfazer 0 \< byteLength \<= 6.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve byteLength bytes de value em buf no offset especificado como big-endian. Suporta até 48 bits de precisão. O comportamento é indefinido quando value é qualquer coisa diferente de um inteiro não assinado.

Esta função também está disponível sob o alias writeUintBE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeUIntBE(0x1234567890ab, 0, 6)

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

CJS

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

const buf = Buffer.allocUnsafe(6)

buf.writeUIntBE(0x1234567890ab, 0, 6)

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

buf.writeUIntLE(value, offset, byteLength)

[Histórico]

Versão	Mudanças
v14.9.0, v12.19.0	Esta função também está disponível como buf.writeUintLE().
v10.0.0	Removido noAssert e sem coerção implícita do offset e byteLength para uint32 mais.
v0.5.5	Adicionado em: v0.5.5

• value <integer> Número a ser escrito em buf.
• offset <integer> Número de bytes a serem ignorados antes de começar a escrever. Deve satisfazer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes a serem escritos. Deve satisfazer 0 \< byteLength \<= 6.
• Retorna: <integer> offset mais o número de bytes escritos.

Escreve byteLength bytes de value em buf no offset especificado como little-endian. Suporta até 48 bits de precisão. O comportamento é indefinido quando value é qualquer coisa diferente de um inteiro não assinado.

Esta função também está disponível sob o alias writeUintLE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeUIntLE(0x1234567890ab, 0, 6)

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

CJS

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

const buf = Buffer.allocUnsafe(6)

buf.writeUIntLE(0x1234567890ab, 0, 6)

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

new Buffer(array)

[Histórico]

Versão	Mudanças
v10.0.0	Chamar este construtor emite um aviso de depreciação quando executado a partir de código fora do diretório node_modules.
v7.2.1	Chamar este construtor não emite mais um aviso de depreciação.
v7.0.0	Chamar este construtor emite um aviso de depreciação agora.
v6.0.0	Obsoleto desde: v6.0.0

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto: Use Buffer.from(array) em vez disso.

• array <integer[]> Uma matriz de bytes para copiar.

Veja Buffer.from(array).

new Buffer(arrayBuffer[, byteOffset[, length]])

[Histórico]

Versão	Mudanças
v10.0.0	Chamar este construtor emite um aviso de depreciação quando executado a partir de código fora do diretório node_modules.
v7.2.1	Chamar este construtor não emite mais um aviso de depreciação.
v7.0.0	Chamar este construtor emite um aviso de depreciação agora.
v6.0.0	Os parâmetros byteOffset e length são suportados agora.
v6.0.0	Obsoleto desde: v6.0.0
v3.0.0	Adicionado em: v3.0.0

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto: Use Buffer.from(arrayBuffer[, byteOffset[, length]]) em vez disso.

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Um ArrayBuffer, SharedArrayBuffer ou a propriedade .buffer de um TypedArray.
• byteOffset <integer> Índice do primeiro byte a ser exposto. Padrão: 0.
• length <integer> Número de bytes a serem expostos. Padrão: arrayBuffer.byteLength - byteOffset.

Veja Buffer.from(arrayBuffer[, byteOffset[, length]]).

new Buffer(buffer)

[Histórico]

Versão	Mudanças
v10.0.0	Chamar este construtor emite um aviso de depreciação quando executado a partir de código fora do diretório node_modules.
v7.2.1	Chamar este construtor não emite mais um aviso de depreciação.
v7.0.0	Chamar este construtor emite um aviso de depreciação agora.
v6.0.0	Obsoleto desde: v6.0.0

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto: Use Buffer.from(buffer) em vez disso.

• buffer <Buffer> | <Uint8Array> Um Buffer existente ou Uint8Array do qual copiar dados.

Consulte Buffer.from(buffer).

new Buffer(size)

[Histórico]

Versão	Mudanças
v10.0.0	Chamar este construtor emite um aviso de depreciação quando executado a partir de código fora do diretório node_modules.
v8.0.0	O new Buffer(size) retornará memória preenchida com zeros por padrão.
v7.2.1	Chamar este construtor não emite mais um aviso de depreciação.
v7.0.0	Chamar este construtor emite um aviso de depreciação agora.
v6.0.0	Obsoleto desde: v6.0.0

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto: Use Buffer.alloc() em vez disso (veja também Buffer.allocUnsafe()).

• size <integer> O comprimento desejado do novo Buffer.

Consulte Buffer.alloc() e Buffer.allocUnsafe(). Esta variante do construtor é equivalente a Buffer.alloc().

new Buffer(string[, encoding])

[Histórico]

Versão	Mudanças
v10.0.0	Chamar este construtor emite um aviso de depreciação quando executado a partir de código fora do diretório node_modules.
v7.2.1	Chamar este construtor não emite mais um aviso de depreciação.
v7.0.0	Chamar este construtor agora emite um aviso de depreciação.
v6.0.0	Depreciado desde: v6.0.0

[Estável: 0 - Depreciado]

Estável: 0 Estabilidade: 0 - Depreciado: Use Buffer.from(string[, encoding]) em vez disso.

• string <string> String para codificar.
• encoding <string> A codificação de string. Padrão: 'utf8'.

Veja Buffer.from(string[, encoding]).

Classe: File

[Histórico]

Versão	Mudanças
v23.0.0	Torna as instâncias de File clonáveis.
v20.0.0	Não é mais experimental.
v19.2.0, v18.13.0	Adicionado em: v19.2.0, v18.13.0

• Estende: <Blob>

Um File fornece informações sobre arquivos.

new buffer.File(sources, fileName[, options])

Adicionado em: v19.2.0, v18.13.0

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> | <File[]> Um array de objetos string, <ArrayBuffer>, <TypedArray>, <DataView>, <File>, ou <Blob> objetos, ou qualquer mistura de tais objetos, que serão armazenados dentro do File.
• fileName <string> O nome do arquivo.
• options <Object>
  • endings <string> Um de 'transparent' ou 'native'. Quando definido como 'native', as quebras de linha nas partes da fonte de string serão convertidas para a quebra de linha nativa da plataforma, conforme especificado por require('node:os').EOL.
  • type <string> O tipo de conteúdo do arquivo.
  • lastModified <number> A data da última modificação do arquivo. Padrão: Date.now().

file.name

Adicionado em: v19.2.0, v18.13.0

• Tipo: <string>

O nome do File.

file.lastModified

Adicionado em: v19.2.0, v18.13.0

• Tipo: <number>

A data da última modificação do File.

APIs do módulo node:buffer

Embora o objeto Buffer esteja disponível como um global, existem APIs adicionais relacionadas a Buffer que estão disponíveis apenas por meio do módulo node:buffer, acessado usando require('node:buffer').

buffer.atob(data)

Adicionado em: v15.13.0, v14.17.0

[Estável: 3 - Legado]

Estável: 3 Estabilidade: 3 - Legado. Use Buffer.from(data, 'base64') em vez disso.

• data <any> A string de entrada codificada em Base64.

Decodifica uma string de dados codificados em Base64 em bytes e codifica esses bytes em uma string usando Latin-1 (ISO-8859-1).

Os data podem ser qualquer valor JavaScript que possa ser transformado em uma string.

Esta função é fornecida apenas para compatibilidade com APIs legadas da plataforma web e nunca deve ser usada em códigos novos, porque elas usam strings para representar dados binários e são anteriores à introdução de arrays tipados em JavaScript. Para código em execução usando APIs do Node.js, a conversão entre strings codificadas em base64 e dados binários deve ser realizada usando Buffer.from(str, 'base64') e buf.toString('base64').

buffer.btoa(data)

Adicionado em: v15.13.0, v14.17.0

[Estável: 3 - Legado]

Estável: 3 Estabilidade: 3 - Legado. Use buf.toString('base64') em vez disso.

• data <any> Uma string ASCII (Latin1).

Decodifica uma string em bytes usando Latin-1 (ISO-8859) e codifica esses bytes em uma string usando Base64.

Os data podem ser qualquer valor JavaScript que possa ser transformado em uma string.

Esta função é fornecida apenas para compatibilidade com APIs legadas da plataforma web e nunca deve ser usada em códigos novos, porque elas usam strings para representar dados binários e são anteriores à introdução de arrays tipados em JavaScript. Para código em execução usando APIs do Node.js, a conversão entre strings codificadas em base64 e dados binários deve ser realizada usando Buffer.from(str, 'base64') e buf.toString('base64').

buffer.isAscii(input)

Adicionado em: v19.6.0, v18.15.0

• input <Buffer> | <ArrayBuffer> | <TypedArray> A entrada para validar.
• Retorna: <boolean>

Esta função retorna true se input contiver apenas dados codificados em ASCII válidos, incluindo o caso em que input está vazio.

Lança um erro se input for um buffer de array desanexado.

buffer.isUtf8(input)

Adicionado em: v19.4.0, v18.14.0

• input <Buffer> | <ArrayBuffer> | <TypedArray> A entrada para validar.
• Retorna: <boolean>

Esta função retorna true se input contiver apenas dados codificados em UTF-8 válidos, incluindo o caso em que input está vazio.

Lança um erro se input for um buffer de array desanexado.

buffer.INSPECT_MAX_BYTES

Adicionado em: v0.5.4

• <integer> Padrão: 50

Retorna o número máximo de bytes que serão retornados quando buf.inspect() for chamado. Isso pode ser substituído por módulos de usuário. Consulte util.inspect() para obter mais detalhes sobre o comportamento de buf.inspect().

buffer.kMaxLength

Adicionado em: v3.0.0

• <integer> O maior tamanho permitido para uma única instância de Buffer.

Um alias para buffer.constants.MAX_LENGTH.

buffer.kStringMaxLength

Adicionado em: v3.0.0

• <integer> O maior comprimento permitido para uma única instância de string.

Um alias para buffer.constants.MAX_STRING_LENGTH.

buffer.resolveObjectURL(id)

Adicionado em: v16.7.0

[Estável: 1 - Experimental]

Estável: 1 Estabilidade: 1 - Experimental

• id <string> Uma string de URL 'blob:nodedata:... retornada por uma chamada anterior para URL.createObjectURL().
• Retorna: <Blob>

Resolve um 'blob:nodedata:...' um objeto <Blob> associado registrado usando uma chamada anterior para URL.createObjectURL().

buffer.transcode(source, fromEnc, toEnc)

[Histórico]

Versão	Mudanças
v8.0.0	O parâmetro source agora pode ser um Uint8Array.
v7.1.0	Adicionado em: v7.1.0

• source <Buffer> | <Uint8Array> Uma instância de Buffer ou Uint8Array.
• fromEnc <string> A codificação atual.
• toEnc <string> A codificação de destino.
• Retorna: <Buffer>

Recodifica a instância de Buffer ou Uint8Array fornecida de uma codificação de caractere para outra. Retorna uma nova instância de Buffer.

Lança um erro se fromEnc ou toEnc especificarem codificações de caractere inválidas ou se a conversão de fromEnc para toEnc não for permitida.

As codificações suportadas por buffer.transcode() são: 'ascii', 'utf8', 'utf16le', 'ucs2', 'latin1' e 'binary'.

O processo de transcodificação usará caracteres de substituição se uma determinada sequência de bytes não puder ser representada adequadamente na codificação de destino. Por exemplo:

ESM

import { Buffer, transcode } from 'node:buffer'

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Imprime: '?'

CJS

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

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Imprime: '?'

Como o sinal de Euro (€) não pode ser representado em US-ASCII, ele é substituído por ? no Buffer transcodificado.

Classe: SlowBuffer

Obsoleto desde: v6.0.0

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto: Use Buffer.allocUnsafeSlow() em vez disso.

Veja Buffer.allocUnsafeSlow(). Esta nunca foi uma classe no sentido de que o construtor sempre retornava uma instância de Buffer, em vez de uma instância de SlowBuffer.

new SlowBuffer(size)

Obsoleto desde: v6.0.0

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto: Use Buffer.allocUnsafeSlow() em vez disso.

• size <integer> O comprimento desejado do novo SlowBuffer.

Veja Buffer.allocUnsafeSlow().

Constantes de Buffer

Adicionado em: v8.2.0

buffer.constants.MAX_LENGTH

[Histórico]

Versão	Mudanças
v22.0.0	O valor foi alterado para 2^31 - 1 em arquiteturas de 64 bits.
v15.0.0	O valor foi alterado para 2^31 em arquiteturas de 64 bits.
v14.0.0	O valor foi alterado de 2^30 - 1 para 2^31 - 1 em arquiteturas de 64 bits.
v8.2.0	Adicionado em: v8.2.0

• <integer> O maior tamanho permitido para uma única instância de Buffer.

Em arquiteturas de 32 bits, este valor atualmente é 2^30 - 1 (cerca de 1 GiB).

Em arquiteturas de 64 bits, este valor atualmente é 2^31 - 1 (cerca de 8 PiB).

Ele reflete v8::TypedArray::kMaxLength por baixo dos panos.

Este valor também está disponível como buffer.kMaxLength.

buffer.constants.MAX_STRING_LENGTH

Adicionado em: v8.2.0

• <integer> O maior comprimento permitido para uma única instância de string.

Representa o maior length que um primitivo string pode ter, contado em unidades de código UTF-16.

Este valor pode depender do motor JS que está sendo usado.

Buffer.from(), Buffer.alloc() e Buffer.allocUnsafe()

Em versões do Node.js anteriores à 6.0.0, instâncias de Buffer eram criadas usando a função construtora Buffer, que aloca o Buffer retornado de maneira diferente dependendo dos argumentos fornecidos:

• Passar um número como primeiro argumento para Buffer() (por exemplo, new Buffer(10)) aloca um novo objeto Buffer do tamanho especificado. Antes do Node.js 8.0.0, a memória alocada para tais instâncias de Buffer não é inicializada e pode conter dados confidenciais. Tais instâncias de Buffer devem ser inicializadas posteriormente usando buf.fill(0) ou escrevendo em todo o Buffer antes de ler dados do Buffer. Embora esse comportamento seja intencional para melhorar o desempenho, a experiência de desenvolvimento demonstrou que é necessária uma distinção mais explícita entre criar um Buffer rápido, mas não inicializado, versus criar um Buffer mais lento, mas mais seguro. Desde o Node.js 8.0.0, Buffer(num) e new Buffer(num) retornam um Buffer com a memória inicializada.
• Passar uma string, array ou Buffer como primeiro argumento copia os dados do objeto passado para o Buffer.
• Passar um ArrayBuffer ou um SharedArrayBuffer retorna um Buffer que compartilha a memória alocada com o buffer de array fornecido.

Como o comportamento de new Buffer() é diferente dependendo do tipo do primeiro argumento, problemas de segurança e confiabilidade podem ser inadvertidamente introduzidos em aplicações quando a validação de argumentos ou a inicialização de Buffer não são realizadas.

Por exemplo, se um invasor puder fazer com que um aplicativo receba um número onde uma string é esperada, o aplicativo pode chamar new Buffer(100) em vez de new Buffer("100"), levando-o a alocar um buffer de 100 bytes em vez de alocar um buffer de 3 bytes com conteúdo "100". Isso é comumente possível usando chamadas de API JSON. Como o JSON distingue entre tipos numéricos e de string, ele permite a injeção de números onde um aplicativo escrito de forma ingênua que não valida sua entrada adequadamente pode esperar receber sempre uma string. Antes do Node.js 8.0.0, o buffer de 100 bytes pode conter dados arbitrários pré-existentes na memória, portanto, pode ser usado para expor segredos na memória a um invasor remoto. Desde o Node.js 8.0.0, a exposição da memória não pode ocorrer porque os dados são preenchidos com zero. No entanto, outros ataques ainda são possíveis, como fazer com que buffers muito grandes sejam alocados pelo servidor, levando à degradação do desempenho ou travamento por exaustão da memória.

Para tornar a criação de instâncias de Buffer mais confiável e menos propensa a erros, as várias formas do construtor new Buffer() foram descontinuadas e substituídas por métodos separados Buffer.from(), Buffer.alloc() e Buffer.allocUnsafe().

Os desenvolvedores devem migrar todos os usos existentes dos construtores new Buffer() para uma dessas novas APIs.

• Buffer.from(array) retorna um novo Buffer que contém uma cópia dos octetos fornecidos.
• Buffer.from(arrayBuffer[, byteOffset[, length]]) retorna um novo Buffer que compartilha a mesma memória alocada que o ArrayBuffer fornecido.
• Buffer.from(buffer) retorna um novo Buffer que contém uma cópia do conteúdo do Buffer fornecido.
• Buffer.from(string[, encoding]) retorna um novo Buffer que contém uma cópia da string fornecida.
• Buffer.alloc(size[, fill[, encoding]]) retorna um novo Buffer inicializado do tamanho especificado. Este método é mais lento do que Buffer.allocUnsafe(size), mas garante que as instâncias de Buffer recém-criadas nunca contenham dados antigos que sejam potencialmente confidenciais. Um TypeError será lançado se size não for um número.
• Buffer.allocUnsafe(size) e Buffer.allocUnsafeSlow(size) retornam cada um um novo Buffer não inicializado do size especificado. Como o Buffer não é inicializado, o segmento alocado de memória pode conter dados antigos que são potencialmente confidenciais.

As instâncias de Buffer retornadas por Buffer.allocUnsafe(), Buffer.from(string), Buffer.concat() e Buffer.from(array) podem ser alocadas fora de um pool de memória interno compartilhado se size for menor ou igual à metade de Buffer.poolSize. As instâncias retornadas por Buffer.allocUnsafeSlow() nunca usam o pool de memória interno compartilhado.

A opção de linha de comando --zero-fill-buffers

Adicionado em: v5.10.0

O Node.js pode ser iniciado usando a opção de linha de comando --zero-fill-buffers para fazer com que todas as instâncias de Buffer recém-alocadas sejam preenchidas com zeros por padrão após a criação. Sem a opção, os buffers criados com Buffer.allocUnsafe(), Buffer.allocUnsafeSlow() e new SlowBuffer(size) não são preenchidos com zeros. O uso desta flag pode ter um impacto negativo mensurável no desempenho. Use a opção --zero-fill-buffers somente quando necessário para garantir que instâncias de Buffer recém-alocadas não contenham dados antigos que sejam potencialmente sensíveis.

$ node --zero-fill-buffers
> Buffer.allocUnsafe(5);
<Buffer 00 00 00 00 00>

O que torna Buffer.allocUnsafe() e Buffer.allocUnsafeSlow() "inseguros"?

Ao chamar Buffer.allocUnsafe() e Buffer.allocUnsafeSlow(), o segmento de memória alocada é não inicializado (não é zerado). Embora esse design torne a alocação de memória bastante rápida, o segmento de memória alocado pode conter dados antigos que são potencialmente sensíveis. Usar um Buffer criado por Buffer.allocUnsafe() sem sobrescrever completamente a memória pode permitir que esses dados antigos sejam vazados quando a memória do Buffer é lida.

Embora existam claras vantagens de desempenho ao usar Buffer.allocUnsafe(), um cuidado extra deve ser tomado para evitar a introdução de vulnerabilidades de segurança em um aplicativo.