Buffer

[Estable: 2 - Estable]

Estable: 2 Estabilidad: 2 - Estable

Código fuente: lib/buffer.js

Los objetos Buffer se utilizan para representar una secuencia de bytes de longitud fija. Muchas APIs de Node.js admiten Buffers.

La clase Buffer es una subclase de la clase Uint8Array de JavaScript y la extiende con métodos que cubren casos de uso adicionales. Las APIs de Node.js también aceptan Uint8Array planos dondequiera que se admitan Buffers.

Si bien la clase Buffer está disponible en el ámbito global, se recomienda referenciarla explícitamente a través de una instrucción import o require.

ESM

import { Buffer } from 'node:buffer'

// Crea un Buffer relleno con ceros de longitud 10.
const buf1 = Buffer.alloc(10)

// Crea un Buffer de longitud 10,
// relleno con bytes que tienen el valor `1`.
const buf2 = Buffer.alloc(10, 1)

// Crea un buffer no inicializado de longitud 10.
// Esto es más rápido que llamar a Buffer.alloc(), pero la instancia
// de Buffer devuelta puede contener datos antiguos que deben
// sobrescribirse usando fill(), write(), u otras funciones que llenan el contenido del Buffer.
const buf3 = Buffer.allocUnsafe(10)

// Crea un Buffer que contiene los bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3])

// Crea un Buffer que contiene los bytes [1, 1, 1, 1] – las entradas
// se truncan usando `(value & 255)` para que quepan en el rango 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Crea un Buffer que contiene los bytes codificados en UTF-8 para la cadena 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (en notación hexadecimal)
// [116, 195, 169, 115, 116] (en notación decimal)
const buf6 = Buffer.from('tést')

// Crea un Buffer que contiene los bytes Latin-1 [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1')

CJS

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

// Crea un Buffer relleno con ceros de longitud 10.
const buf1 = Buffer.alloc(10)

// Crea un Buffer de longitud 10,
// relleno con bytes que tienen el valor `1`.
const buf2 = Buffer.alloc(10, 1)

// Crea un buffer no inicializado de longitud 10.
// Esto es más rápido que llamar a Buffer.alloc(), pero la instancia
// de Buffer devuelta puede contener datos antiguos que deben
// sobrescribirse usando fill(), write(), u otras funciones que llenan el contenido del Buffer.
const buf3 = Buffer.allocUnsafe(10)

// Crea un Buffer que contiene los bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3])

// Crea un Buffer que contiene los bytes [1, 1, 1, 1] – las entradas
// se truncan usando `(value & 255)` para que quepan en el rango 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Crea un Buffer que contiene los bytes codificados en UTF-8 para la cadena 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (en notación hexadecimal)
// [116, 195, 169, 115, 116] (en notación decimal)
const buf6 = Buffer.from('tést')

// Crea un Buffer que contiene los bytes Latin-1 [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1')

Buffers y codificaciones de caracteres

[Historial]

Versión	Cambios
v15.7.0, v14.18.0	Se introdujo la codificación base64url.
v6.4.0	Se introdujo latin1 como alias para binary.
v5.0.0	Se eliminaron las codificaciones obsoletas raw y raws.

Al convertir entre Buffer y cadenas, se puede especificar una codificación de caracteres. Si no se especifica ninguna codificación de caracteres, se utilizará UTF-8 como predeterminada.

ESM

import { Buffer } from 'node:buffer'

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

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

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('hello world', 'utf8')

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

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>

Los buffers de Node.js aceptan todas las variaciones de mayúsculas y minúsculas de las cadenas de codificación que reciben. Por ejemplo, UTF-8 se puede especificar como 'utf8', 'UTF8' o 'uTf8'.

Las codificaciones de caracteres actualmente compatibles con Node.js son las siguientes:

• 'utf8' (alias: 'utf-8'): Caracteres Unicode codificados en varios bytes. Muchas páginas web y otros formatos de documentos utilizan UTF-8. Esta es la codificación de caracteres predeterminada. Al decodificar un Buffer en una cadena que no contiene exclusivamente datos UTF-8 válidos, el carácter de reemplazo Unicode U+FFFD � se utilizará para representar esos errores.
• 'utf16le' (alias: 'utf-16le'): Caracteres Unicode codificados en varios bytes. A diferencia de 'utf8', cada carácter de la cadena se codificará utilizando 2 o 4 bytes. Node.js solo admite la variante little-endian de UTF-16.
• 'latin1': Latin-1 significa ISO-8859-1. Esta codificación de caracteres solo admite los caracteres Unicode de U+0000 a U+00FF. Cada carácter se codifica utilizando un solo byte. Los caracteres que no encajan en ese rango se truncan y se asignarán a caracteres de ese rango.

Convertir un Buffer en una cadena utilizando uno de los anteriores se conoce como decodificación, y convertir una cadena en un Buffer se conoce como codificación.

Node.js también admite las siguientes codificaciones binario-texto. Para las codificaciones binario-texto, la convención de nomenclatura se invierte: convertir un Buffer en una cadena se conoce normalmente como codificación, y convertir una cadena en un Buffer como decodificación.

• 'base64': Codificación Base64. Al crear un Buffer a partir de una cadena, esta codificación también aceptará correctamente el "Alfabeto seguro para URL y nombres de archivo" como se especifica en RFC 4648, Sección 5. Los caracteres de espacio en blanco, como espacios, tabulaciones y nuevas líneas contenidos en la cadena codificada en base64, se ignoran.
• 'base64url': Codificación base64url como se especifica en RFC 4648, Sección 5. Al crear un Buffer a partir de una cadena, esta codificación también aceptará correctamente las cadenas codificadas en base64 regulares. Al codificar un Buffer en una cadena, esta codificación omitirá el relleno.
• 'hex': Codifica cada byte como dos caracteres hexadecimales. Puede producirse un truncamiento de datos al decodificar cadenas que no consisten exclusivamente en un número par de caracteres hexadecimales. Consulte a continuación un ejemplo.

También se admiten las siguientes codificaciones de caracteres heredadas:

• 'ascii': Solo para datos ASCII de 7 bits. Al codificar una cadena en un Buffer, esto es equivalente a usar 'latin1'. Al decodificar un Buffer en una cadena, el uso de esta codificación también anulará el bit más alto de cada byte antes de decodificar como 'latin1'. En general, no debería haber ninguna razón para usar esta codificación, ya que 'utf8' (o, si se sabe que los datos son solo ASCII, 'latin1') será una mejor opción al codificar o decodificar texto solo ASCII. Solo se proporciona para compatibilidad heredada.
• 'binary': Alias para 'latin1'. El nombre de esta codificación puede ser muy engañoso, ya que todas las codificaciones enumeradas aquí convierten entre cadenas y datos binarios. Para convertir entre cadenas y Buffer, normalmente 'utf8' es la opción correcta.
• 'ucs2', 'ucs-2': Alias de 'utf16le'. UCS-2 solía referirse a una variante de UTF-16 que no admitía caracteres con puntos de código mayores que U+FFFF. En Node.js, estos puntos de código siempre son compatibles.

ESM

import { Buffer } from 'node:buffer'

Buffer.from('1ag123', 'hex')
// Imprime <Buffer 1a>, datos truncados cuando se encuentra el primer valor no hexadecimal
// ('g').

Buffer.from('1a7', 'hex')
// Imprime <Buffer 1a>, datos truncados cuando los datos terminan en un solo dígito ('7').

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

CJS

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

Buffer.from('1ag123', 'hex')
// Imprime <Buffer 1a>, datos truncados cuando se encuentra el primer valor no hexadecimal
// ('g').

Buffer.from('1a7', 'hex')
// Imprime <Buffer 1a>, datos truncados cuando los datos terminan en un solo dígito ('7').

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

Los navegadores web modernos siguen el Estándar de codificación WHATWG que asigna como alias tanto 'latin1' como 'ISO-8859-1' a 'win-1252'. Esto significa que al hacer algo como http.get(), si el juego de caracteres devuelto es uno de los enumerados en la especificación WHATWG, es posible que el servidor haya devuelto datos codificados en 'win-1252', y el uso de la codificación 'latin1' puede decodificar incorrectamente los caracteres.

Buffers y TypedArrays

[Historial]

Versión	Cambios
v3.0.0	La clase Buffer ahora hereda de Uint8Array.

Las instancias de Buffer también son instancias de Uint8Array y TypedArray de JavaScript. Todos los métodos de TypedArray están disponibles en Buffer. Sin embargo, existen incompatibilidades sutiles entre la API de Buffer y la API de TypedArray.

En particular:

• Mientras que TypedArray.prototype.slice() crea una copia de parte del TypedArray, Buffer.prototype.slice() crea una vista sobre el Buffer existente sin copiar. Este comportamiento puede ser sorprendente y solo existe por compatibilidad con versiones anteriores. TypedArray.prototype.subarray() se puede usar para lograr el comportamiento de Buffer.prototype.slice() tanto en Buffer como en otros TypedArray y debería preferirse.
• buf.toString() es incompatible con su equivalente TypedArray.
• Varios métodos, por ejemplo, buf.indexOf(), admiten argumentos adicionales.

Hay dos maneras de crear nuevas instancias de TypedArray a partir de un Buffer:

• Pasar un Buffer a un constructor TypedArray copiará el contenido del Buffer, interpretado como una matriz de enteros, y no como una secuencia de bytes del 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 ]

• Pasar el ArrayBuffer subyacente del Buffer creará un TypedArray que comparte su memoria con el 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 ]

Es posible crear un nuevo Buffer que comparta la misma memoria asignada que una instancia de TypedArray utilizando la propiedad .buffer del objeto TypedArray de la misma manera. Buffer.from() se comporta como new Uint8Array() en este contexto.

ESM

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

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

// Copia el contenido de `arr`.
const buf1 = Buffer.from(arr)

// Comparte memoria con `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 el contenido de `arr`.
const buf1 = Buffer.from(arr)

// Comparte memoria con `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>

Al crear un Buffer usando .buffer de un TypedArray, es posible usar solo una parte del ArrayBuffer subyacente pasando los parámetros byteOffset y 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() y TypedArray.from() tienen diferentes firmas e implementaciones. Específicamente, las variantes de TypedArray aceptan un segundo argumento que es una función de mapeo que se invoca en cada elemento de la matriz tipada:

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

El método Buffer.from(), sin embargo, no admite el uso de una función de mapeo:

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

Buffers e iteración

Las instancias de Buffer se pueden iterar usando la sintaxis 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

Adicionalmente, los métodos buf.values(), buf.keys(), y buf.entries() se pueden usar para crear iteradores.

Clase: Blob

[Historial]

Versión	Cambios
v18.0.0, v16.17.0	Ya no es experimental.
v15.7.0, v14.18.0	Añadido en: v15.7.0, v14.18.0

Un Blob encapsula datos crudos inmutables que se pueden compartir de forma segura entre múltiples hilos de trabajo.

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

[Historial]

Versión	Cambios
v16.7.0	Se añadió la opción estándar endings para reemplazar los saltos de línea, y se eliminó la opción no estándar encoding.
v15.7.0, v14.18.0	Añadido en: v15.7.0, v14.18.0

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> Un array de objetos string, <ArrayBuffer>, <TypedArray>, <DataView>, o <Blob>, o cualquier mezcla de dichos objetos, que se almacenarán dentro del Blob.
• options <Object>
  • endings <string> Uno de 'transparent' o 'native'. Cuando se establece en 'native', los saltos de línea en las partes de origen de la cadena se convertirán al salto de línea nativo de la plataforma como se especifica mediante require('node:os').EOL.
  • type <string> El tipo de contenido del Blob. La intención es que type transmita el tipo de medio MIME de los datos, sin embargo, no se realiza ninguna validación del formato del tipo.

Crea un nuevo objeto Blob que contiene una concatenación de las fuentes dadas.

Las fuentes <ArrayBuffer>, <TypedArray>, <DataView>, y <Buffer> se copian en el 'Blob' y, por lo tanto, se pueden modificar de forma segura después de que se cree el 'Blob'.

Las fuentes de cadena se codifican como secuencias de bytes UTF-8 y se copian en el Blob. Los pares sustitutos no coincidentes dentro de cada parte de la cadena se reemplazarán por caracteres de reemplazo Unicode U+FFFD.

blob.arrayBuffer()

Añadido en: v15.7.0, v14.18.0

• Devuelve: <Promise>

Devuelve una promesa que se cumple con un <ArrayBuffer> que contiene una copia de los datos del Blob.

blob.bytes()

Añadido en: v22.3.0, v20.16.0

El método blob.bytes() devuelve el byte del objeto Blob como un Promise\<Uint8Array\>.

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

blob.size

Añadido en: v15.7.0, v14.18.0

El tamaño total del Blob en bytes.

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

Añadido en: v15.7.0, v14.18.0

• start <number> El índice de inicio.
• end <number> El índice final.
• type <string> El tipo de contenido para el nuevo Blob

Crea y devuelve un nuevo Blob que contiene un subconjunto de los datos de este objeto Blob. El Blob original no se altera.

blob.stream()

Añadido en: v16.7.0

• Devuelve: <ReadableStream>

Devuelve un nuevo ReadableStream que permite leer el contenido del Blob.

blob.text()

Añadido en: v15.7.0, v14.18.0

• Devuelve: <Promise>

Devuelve una promesa que se completa con el contenido del Blob decodificado como una cadena UTF-8.

blob.type

Añadido en: v15.7.0, v14.18.0

• Tipo: <string>

El tipo de contenido del Blob.

Objetos Blob y MessageChannel

Una vez que se crea un objeto <Blob>, se puede enviar a través de MessagePort a múltiples destinos sin transferir o copiar inmediatamente los datos. Los datos contenidos en el Blob solo se copian cuando se llaman a los métodos arrayBuffer() o text().

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)

// El Blob sigue siendo utilizable después de la publicación.
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)

// El Blob sigue siendo utilizable después de la publicación.
blob.text().then(console.log)

Clase: Buffer

La clase Buffer es un tipo global para tratar datos binarios directamente. Puede ser construida de varias maneras.

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

[Historial]

Versión	Cambios
v20.0.0	Lanza ERR_INVALID_ARG_TYPE o ERR_OUT_OF_RANGE en lugar de ERR_INVALID_ARG_VALUE para argumentos de entrada inválidos.
v15.0.0	Lanza ERR_INVALID_ARG_VALUE en lugar de ERR_INVALID_OPT_VALUE para argumentos de entrada inválidos.
v10.0.0	Intentar llenar un búfer de longitud no nula con un búfer de longitud cero provoca una excepción lanzada.
v10.0.0	Especificar una cadena inválida para fill provoca una excepción lanzada.
v8.9.3	Especificar una cadena inválida para fill ahora resulta en un búfer relleno con ceros.
v5.10.0	Añadido en: v5.10.0

• size <integer> La longitud deseada del nuevo Buffer.
• fill <string> | <Buffer> | <Uint8Array> | <integer> Un valor para pre-llenar el nuevo Buffer. Predeterminado: 0.
• encoding <string> Si fill es una cadena, esta es su codificación. Predeterminado: 'utf8'.
• Devuelve: <Buffer>

Asigna un nuevo Buffer de size bytes. Si fill es undefined, el Buffer se rellenará con ceros.

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>

Si size es mayor que buffer.constants.MAX_LENGTH o menor que 0, se lanza ERR_OUT_OF_RANGE.

Si se especifica fill, el Buffer asignado se inicializará llamando a 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>

Si se especifican tanto fill como encoding, el Buffer asignado se inicializará llamando a 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>

Llamar a Buffer.alloc() puede ser perceptiblemente más lento que la alternativa Buffer.allocUnsafe() pero asegura que el contenido de la instancia Buffer recién creada nunca contendrá datos sensibles de asignaciones anteriores, incluyendo datos que podrían no haber sido asignados para Buffers.

Se lanzará un TypeError si size no es un número.

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

[Historial]

Versión	Cambios
v20.0.0	Lanza ERR_INVALID_ARG_TYPE o ERR_OUT_OF_RANGE en lugar de ERR_INVALID_ARG_VALUE para argumentos de entrada inválidos.
v15.0.0	Lanza ERR_INVALID_ARG_VALUE en lugar de ERR_INVALID_OPT_VALUE para argumentos de entrada inválidos.
v7.0.0	Pasar un size negativo ahora lanzará un error.
v5.10.0	Añadido en: v5.10.0

• size <integer> La longitud deseada del nuevo Buffer.
• Devuelve: <Buffer>

Asigna un nuevo Buffer de size bytes. Si size es mayor que buffer.constants.MAX_LENGTH o menor que 0, se lanza ERR_OUT_OF_RANGE.

La memoria subyacente para las instancias de Buffer creadas de esta manera no está inicializada. El contenido del Buffer recién creado es desconocido y puede contener datos sensibles. Utilice Buffer.alloc() en su lugar para inicializar instancias de Buffer con ceros.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(10)

console.log(buf)
// Imprime (el contenido puede 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 (el contenido puede 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>

Se lanzará un TypeError si size no es un número.

El módulo Buffer preasigna una instancia interna de Buffer de tamaño Buffer.poolSize que se utiliza como un pool para la asignación rápida de nuevas instancias de Buffer creadas usando Buffer.allocUnsafe(), Buffer.from(array), Buffer.from(string), y Buffer.concat() solo cuando size es menor que Buffer.poolSize \>\>\> 1 (piso de Buffer.poolSize dividido por dos).

El uso de este pool de memoria interna preasignada es una diferencia clave entre llamar a Buffer.alloc(size, fill) vs. Buffer.allocUnsafe(size).fill(fill). Específicamente, Buffer.alloc(size, fill) nunca usará el pool interno de Buffer, mientras que Buffer.allocUnsafe(size).fill(fill) usará el pool interno de Buffer si size es menor o igual a la mitad de Buffer.poolSize. La diferencia es sutil, pero puede ser importante cuando una aplicación requiere el rendimiento adicional que Buffer.allocUnsafe() proporciona.

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

[Historial]

Versión	Cambios
v20.0.0	Lanza ERR_INVALID_ARG_TYPE o ERR_OUT_OF_RANGE en lugar de ERR_INVALID_ARG_VALUE para argumentos de entrada no válidos.
v15.0.0	Lanza ERR_INVALID_ARG_VALUE en lugar de ERR_INVALID_OPT_VALUE para argumentos de entrada no válidos.
v5.12.0	Añadido en: v5.12.0

• size <integer> La longitud deseada del nuevo Buffer.
• Devuelve: <Buffer>

Asigna un nuevo Buffer de size bytes. Si size es mayor que buffer.constants.MAX_LENGTH o menor que 0, se lanza ERR_OUT_OF_RANGE. Se crea un Buffer de longitud cero si size es 0.

La memoria subyacente para las instancias de Buffer creadas de esta manera no está inicializada. El contenido del Buffer recién creado es desconocido y puede contener datos sensibles. Use buf.fill(0) para inicializar dichas instancias de Buffer con ceros.

Cuando se utiliza Buffer.allocUnsafe() para asignar nuevas instancias de Buffer, las asignaciones menores que Buffer.poolSize \>\>\> 1 (4KiB cuando se utiliza el tamaño de grupo predeterminado) se cortan de un solo Buffer preasignado. Esto permite a las aplicaciones evitar la sobrecarga de recolección de basura de crear muchas instancias de Buffer asignadas individualmente. Este enfoque mejora tanto el rendimiento como el uso de la memoria al eliminar la necesidad de rastrear y limpiar tantos objetos ArrayBuffer individuales.

Sin embargo, en el caso de que un desarrollador necesite conservar un pequeño fragmento de memoria de un grupo durante un tiempo indeterminado, puede ser apropiado crear una instancia de Buffer no agrupada usando Buffer.allocUnsafeSlow() y luego copiar los bits relevantes.

ESM

import { Buffer } from 'node:buffer'

// Necesito mantener algunos pequeños fragmentos de memoria.
const store = []

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

    // Copiar los datos en la nueva asignación.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

CJS

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

// Necesito mantener algunos pequeños fragmentos de memoria.
const store = []

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

    // Copiar los datos en la nueva asignación.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

Se lanzará un TypeError si size no es un número.

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

[Historial]

Versión	Cambios
v7.0.0	Pasar una entrada inválida ahora arrojará un error.
v5.10.0	El parámetro string ahora puede ser cualquier TypedArray, DataView o ArrayBuffer.
v0.1.90	Añadido en: v0.1.90

• string <string> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> Un valor para calcular la longitud de.
• encoding <string> Si string es una cadena, esta es su codificación. Predeterminado: 'utf8'.
• Devuelve: <integer> El número de bytes contenidos en string.

Devuelve la longitud en bytes de una cadena cuando se codifica usando encoding. Esto no es lo mismo que String.prototype.length, que no tiene en cuenta la codificación que se utiliza para convertir la cadena en bytes.

Para 'base64', 'base64url' y 'hex', esta función asume una entrada válida. Para cadenas que contienen datos no codificados en base64/hex (por ejemplo, espacios en blanco), el valor devuelto puede ser mayor que la longitud de un Buffer creado a partir de la cadena.

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

Cuando string es un Buffer/ DataView/TypedArray/ArrayBuffer/SharedArrayBuffer, se devuelve la longitud en bytes según lo informado por .byteLength.

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

[Historial]

Versión	Cambios
v8.0.0	Los argumentos ahora pueden ser Uint8Array.
v0.11.13	Añadido en: v0.11.13

• buf1 <Buffer> | <Uint8Array>
• buf2 <Buffer> | <Uint8Array>
• Devuelve: <integer> -1, 0, o 1, dependiendo del resultado de la comparación. Ver buf.compare() para más detalles.

Compara buf1 con buf2, normalmente con el propósito de ordenar matrices de instancias de Buffer. Esto es equivalente a llamar a 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 es 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 es igual a: [buf2, buf1].)

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

[Historial]

Versión	Cambios
v8.0.0	Los elementos de list ahora pueden ser Uint8Array.
v0.7.11	Añadido en: v0.7.11

• list <Buffer[]> | <Uint8Array[]> Lista de instancias de Buffer o Uint8Array para concatenar.
• totalLength <integer> Longitud total de las instancias de Buffer en list cuando se concatenan.
• Devuelve: <Buffer>

Devuelve un nuevo Buffer que es el resultado de concatenar todas las instancias de Buffer en la lista list.

Si la lista no tiene elementos, o si totalLength es 0, entonces se devuelve un nuevo Buffer de longitud cero.

Si no se proporciona totalLength, se calcula a partir de las instancias de Buffer en list sumando sus longitudes.

Si se proporciona totalLength, se convierte a un entero sin signo. Si la longitud combinada de los Buffer en list excede totalLength, el resultado se trunca a totalLength. Si la longitud combinada de los Buffer en list es menor que totalLength, el espacio restante se rellena con ceros.

ESM

import { Buffer } from 'node:buffer'

// Crear un único `Buffer` a partir de una lista de tres instancias 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')

// Crear un único `Buffer` a partir de una lista de tres instancias 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() también puede usar el pool interno de Buffer como lo hace Buffer.allocUnsafe().

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

Añadido en: v19.8.0, v18.16.0

• view <TypedArray> El <TypedArray> a copiar.
• offset <integer> El desplazamiento inicial dentro de view. Predeterminado: 0.
• length <integer> El número de elementos de view a copiar. Predeterminado: view.length - offset.
• Devuelve: <Buffer>

Copia la memoria subyacente de view en un nuevo 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)

Añadido en: v5.10.0

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

Asigna un nuevo Buffer usando un array de bytes en el rango 0 – 255. Las entradas del array fuera de ese rango se truncarán para que quepan en él.

ESM

import { Buffer } from 'node:buffer'

// Crea un nuevo Buffer que contiene los bytes UTF-8 de la cadena 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

CJS

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

// Crea un nuevo Buffer que contiene los bytes UTF-8 de la cadena 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

Si array es un objeto similar a un Array (es decir, uno con una propiedad length de tipo number), se trata como si fuera un array, a menos que sea un Buffer o un Uint8Array. Esto significa que todas las demás variantes de TypedArray se tratan como un Array. Para crear un Buffer a partir de los bytes que respaldan un TypedArray, use Buffer.copyBytesFrom().

Se lanzará un TypeError si array no es un Array u otro tipo apropiado para las variantes de Buffer.from().

Buffer.from(array) y Buffer.from(string) también pueden usar el grupo de Buffer interno como lo hace Buffer.allocUnsafe().

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

Añadido en: v5.10.0

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Un ArrayBuffer, SharedArrayBuffer, por ejemplo, la propiedad .buffer de un TypedArray.
• byteOffset <integer> Índice del primer byte a exponer. Predeterminado: 0.
• length <integer> Número de bytes a exponer. Predeterminado: arrayBuffer.byteLength - byteOffset.
• Devuelve: <Buffer>

Esto crea una vista del ArrayBuffer sin copiar la memoria subyacente. Por ejemplo, cuando se pasa una referencia a la propiedad .buffer de una instancia de TypedArray, el Buffer recién creado compartirá la misma memoria asignada que el ArrayBuffer subyacente del TypedArray.

ESM

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

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

// Comparte memoria con `arr`.
const buf = Buffer.from(arr.buffer)

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

// Cambiar el Uint16Array original también cambia el 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

// Comparte memoria con `arr`.
const buf = Buffer.from(arr.buffer)

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

// Cambiar el Uint16Array original también cambia el Buffer.
arr[1] = 6000

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

Los argumentos opcionales byteOffset y length especifican un rango de memoria dentro del arrayBuffer que será compartido por el 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

Se lanzará un TypeError si arrayBuffer no es un ArrayBuffer o un SharedArrayBuffer u otro tipo apropiado para las variantes de Buffer.from().

Es importante recordar que un ArrayBuffer de respaldo puede cubrir un rango de memoria que se extiende más allá de los límites de una vista TypedArray. Un nuevo Buffer creado usando la propiedad buffer de un TypedArray puede extenderse más allá del rango del 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)

Añadido en: v5.10.0

• buffer <Buffer> | <Uint8Array> Un Buffer existente o un Uint8Array desde el cual copiar datos.
• Devuelve: <Buffer>

Copia los datos del buffer pasado a una nueva instancia 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

Se lanzará un TypeError si buffer no es un Buffer u otro tipo apropiado para las variantes de Buffer.from().

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

Añadido en: v8.2.0

• object <Object> Un objeto que admite Symbol.toPrimitive o valueOf().
• offsetOrEncoding <integer> | <string> Un desplazamiento de bytes o codificación.
• length <integer> Una longitud.
• Devuelve: <Buffer>

Para objetos cuya función valueOf() devuelve un valor que no es estrictamente igual a object, devuelve 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 admiten Symbol.toPrimitive, devuelve 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>

Se lanzará un TypeError si object no tiene los métodos mencionados o no es de otro tipo apropiado para las variantes de Buffer.from().

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

Añadido en: v5.10.0

• string <string> Una cadena para codificar.
• encoding <string> La codificación de string. Predeterminado: 'utf8'.
• Devuelve: <Buffer>

Crea un nuevo Buffer que contiene string. El parámetro encoding identifica la codificación de caracteres que se utilizará al convertir string en 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

Se lanzará un TypeError si string no es una cadena u otro tipo apropiado para las variantes de Buffer.from().

Buffer.from(string) también puede usar el grupo de Buffer interno como lo hace Buffer.allocUnsafe().

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

Añadido en: v0.1.101

• obj <Object>
• Devuelve: <boolean>

Devuelve true si obj es un Buffer, false en caso contrario.

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)

Añadido en: v0.9.1

• encoding <string> Un nombre de codificación de caracteres para verificar.
• Devuelve: <boolean>

Devuelve true si encoding es el nombre de una codificación de caracteres soportada, o false en caso contrario.

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

Propiedad de clase: Buffer.poolSize

Añadido en: v0.11.3

• <integer> Predeterminado: 8192

Este es el tamaño (en bytes) de las instancias internas de Buffer preasignadas utilizadas para la agrupación. Este valor puede modificarse.

buf[index]

• index <integer>

El operador de índice [index] se puede utilizar para obtener y establecer el octeto en la posición index en buf. Los valores se refieren a bytes individuales, por lo que el rango de valores legales está entre 0x00 y 0xFF (hexadecimal) o 0 y 255 (decimal).

Este operador se hereda de Uint8Array, por lo que su comportamiento en el acceso fuera de los límites es el mismo que Uint8Array. En otras palabras, buf[index] devuelve undefined cuando index es negativo o mayor o igual a buf.length, y buf[index] = value no modifica el búfer si index es negativo o \>= buf.length.

ESM

import { Buffer } from 'node:buffer'

// Copiar una cadena ASCII en un `Buffer` un byte a la vez.
// (Esto solo funciona para cadenas solo ASCII. En general, se debe usar
// `Buffer.from()` para realizar esta conversión).

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')

// Copiar una cadena ASCII en un `Buffer` un byte a la vez.
// (Esto solo funciona para cadenas solo ASCII. En general, se debe usar
// `Buffer.from()` para realizar esta conversión).

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> El objeto ArrayBuffer subyacente en el que se crea este objeto Buffer.

Este ArrayBuffer no está garantizado que corresponda exactamente al Buffer original. Consulte las notas sobre buf.byteOffset para obtener más detalles.

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> El byteOffset del objeto ArrayBuffer subyacente del Buffer.

Al establecer byteOffset en Buffer.from(ArrayBuffer, byteOffset, length), o a veces al asignar un Buffer menor que Buffer.poolSize, el búfer no comienza desde un desplazamiento cero en el ArrayBuffer subyacente.

Esto puede causar problemas al acceder al ArrayBuffer subyacente directamente usando buf.buffer, ya que otras partes del ArrayBuffer pueden no estar relacionadas con el objeto Buffer en sí.

Un problema común al crear un objeto TypedArray que comparte su memoria con un Buffer es que, en este caso, es necesario especificar el byteOffset correctamente:

ESM

import { Buffer } from 'node:buffer'

// Crea un búfer menor que `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// Al convertir el búfer Node.js a un Int8Array, use el byteOffset
// para referirse solo a la parte de `nodeBuffer.buffer` que contiene la memoria
// para `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

CJS

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

// Crea un búfer menor que `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// Al convertir el búfer Node.js a un Int8Array, use el byteOffset
// para referirse solo a la parte de `nodeBuffer.buffer` que contiene la memoria
// para `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

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

[Historial]

Versión	Cambios
v8.0.0	El parámetro target ahora puede ser un Uint8Array.
v5.11.0	Ahora se admiten parámetros adicionales para especificar los desplazamientos.
v0.11.13	Añadido en: v0.11.13

• target <Buffer> | <Uint8Array> Un Buffer o Uint8Array con el que comparar buf.
• targetStart <integer> El desplazamiento dentro de target en el que comenzar la comparación. Predeterminado: 0.
• targetEnd <integer> El desplazamiento dentro de target en el que finalizar la comparación (no inclusivo). Predeterminado: target.length.
• sourceStart <integer> El desplazamiento dentro de buf en el que comenzar la comparación. Predeterminado: 0.
• sourceEnd <integer> El desplazamiento dentro de buf en el que finalizar la comparación (no inclusivo). Predeterminado: buf.length.
• Devuelve: <integer>

Compara buf con target y devuelve un número que indica si buf viene antes, después o es igual que target en el orden de clasificación. La comparación se basa en la secuencia real de bytes en cada Buffer.

• Se devuelve 0 si target es igual a buf.
• Se devuelve 1 si target debe venir antes que buf cuando se ordena.
• Se devuelve -1 si target debe venir después que buf cuando se ordena.

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 es 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 es igual a: [buf1, buf3, buf2].)

Los argumentos opcionales targetStart, targetEnd, sourceStart y sourceEnd se pueden usar para limitar la comparación a rangos específicos dentro de target y 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

Se lanza ERR_OUT_OF_RANGE si targetStart \< 0, sourceStart \< 0, targetEnd \> target.byteLength, o sourceEnd \> source.byteLength.

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

Añadido en: v0.1.90

• target <Buffer> | <Uint8Array> Un Buffer o Uint8Array en el que copiar.
• targetStart <integer> El desplazamiento dentro de target en el que comenzar a escribir. Predeterminado: 0.
• sourceStart <integer> El desplazamiento dentro de buf desde el que comenzar a copiar. Predeterminado: 0.
• sourceEnd <integer> El desplazamiento dentro de buf en el que detener la copia (no inclusivo). Predeterminado: buf.length.
• Devuelve: <integer> El número de bytes copiados.

Copia datos de una región de buf a una región en target, incluso si la región de memoria target se superpone con buf.

TypedArray.prototype.set() realiza la misma operación y está disponible para todos los TypedArrays, incluidos los Buffer de Node.js, aunque toma argumentos de función diferentes.

ESM

import { Buffer } from 'node:buffer'

// Crea dos instancias de `Buffer`.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

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

// Copia los bytes 16 a 19 de `buf1` en `buf2` comenzando en el byte 8 de `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Esto es equivalente a:
// buf2.set(buf1.subarray(16, 20), 8);

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

CJS

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

// Crea dos instancias de `Buffer`.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

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

// Copia los bytes 16 a 19 de `buf1` en `buf2` comenzando en el byte 8 de `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Esto es equivalente a:
// buf2.set(buf1.subarray(16, 20), 8);

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

ESM

import { Buffer } from 'node:buffer'

// Crea un `Buffer` y copia datos de una región a una región superpuesta
// dentro del mismo `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 es el 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')

// Crea un `Buffer` y copia datos de una región a una región superpuesta
// dentro del mismo `Buffer`.

const buf = Buffer.allocUnsafe(26)

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

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

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

buf.entries()

Añadido en: v1.1.0

• Devuelve: <Iterator>

Crea y devuelve un iterador de pares [índice, byte] del contenido de buf.

ESM

import { Buffer } from 'node:buffer'

// Registra todo el contenido de un `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 el contenido de un `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)

[Historial]

Versión	Cambios
v8.0.0	Los argumentos ahora pueden ser Uint8Arrays.
v0.11.13	Añadido en: v0.11.13

• otherBuffer <Buffer> | <Uint8Array> Un Buffer o Uint8Array con el que comparar buf.
• Devuelve: <boolean>

Devuelve true si tanto buf como otherBuffer tienen exactamente los mismos bytes, false en caso contrario. 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])

[Historial]

Versión	Cambios
v11.0.0	Lanza ERR_OUT_OF_RANGE en lugar de ERR_INDEX_OUT_OF_RANGE.
v10.0.0	Los valores end negativos lanzan un error ERR_INDEX_OUT_OF_RANGE.
v10.0.0	Intentar llenar un búfer de longitud no cero con un búfer de longitud cero provoca una excepción lanzada.
v10.0.0	Especificar una cadena no válida para value provoca una excepción lanzada.
v5.7.0	El parámetro encoding ahora es compatible.
v0.5.0	Añadido en: v0.5.0

• value <string> | <Buffer> | <Uint8Array> | <integer> El valor con el que llenar buf. El valor vacío (string, Uint8Array, Buffer) se convierte en 0.
• offset <integer> Número de bytes que se deben omitir antes de comenzar a llenar buf. Predeterminado: 0.
• end <integer> Dónde detener el llenado de buf (no inclusivo). Predeterminado: buf.length.
• encoding <string> La codificación para value si value es una cadena. Predeterminado: 'utf8'.
• Devuelve: <Buffer> Una referencia a buf.

Llena buf con el value especificado. Si no se dan offset y end, se llenará todo buf:

ESM

import { Buffer } from 'node:buffer'

// Llenar un `Buffer` con el carácter ASCII 'h'.

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

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

// Llenar un búfer con una cadena vacía
const c = Buffer.allocUnsafe(5).fill('')

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

CJS

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

// Llenar un `Buffer` con el carácter ASCII 'h'.

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

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

// Llenar un búfer con una cadena vacía
const c = Buffer.allocUnsafe(5).fill('')

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

value se convierte a un valor uint32 si no es una cadena, Buffer o entero. Si el entero resultante es mayor que 255 (decimal), buf se llenará con value & 255.

Si la escritura final de una operación fill() cae en un carácter de varios bytes, solo se escriben los bytes de ese carácter que caben en buf:

ESM

import { Buffer } from 'node:buffer'

// Llenar un `Buffer` con un carácter que ocupa dos bytes en UTF-8.

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

CJS

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

// Llenar un `Buffer` con un carácter que ocupa dos bytes en UTF-8.

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

Si value contiene caracteres inválidos, se trunca; si no quedan datos de relleno válidos, se lanza una excepción:

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'))
// Lanza una excepción.

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'))
// Lanza una excepción.

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

Añadido en: v5.3.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Qué buscar.
• byteOffset <integer> Dónde empezar a buscar en buf. Si es negativo, el desplazamiento se calcula desde el final de buf. Predeterminado: 0.
• encoding <string> Si value es una cadena, esta es su codificación. Predeterminado: 'utf8'.
• Devuelve: <boolean> true si value se encontró en buf, false de lo contrario.

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 es el 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 es el 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])

[Historial]

Versión	Cambios
v8.0.0	El value ahora puede ser un Uint8Array.
v5.7.0, v4.4.0	Cuando se pasa encoding, el parámetro byteOffset ya no es requerido.
v1.5.0	Añadido en: v1.5.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Qué buscar.
• byteOffset <integer> Dónde empezar a buscar en buf. Si es negativo, el desplazamiento se calcula desde el final de buf. Predeterminado: 0.
• encoding <string> Si value es una cadena, esta es la codificación usada para determinar la representación binaria de la cadena que se buscará en buf. Predeterminado: 'utf8'.
• Devuelve: <integer> El índice de la primera ocurrencia de value en buf, o -1 si buf no contiene value.

Si value es:

• una cadena, value se interpreta según la codificación de caracteres en encoding.
• un Buffer o Uint8Array, value se usará en su totalidad. Para comparar un Buffer parcial, use buf.subarray.
• un número, value se interpretará como un valor entero sin signo de 8 bits entre 0 y 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 es el 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 es el 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

Si value no es una cadena, un número o un Buffer, este método lanzará un TypeError. Si value es un número, se forzará a un valor de byte válido, un entero entre 0 y 255.

Si byteOffset no es un número, se forzará a un número. Si el resultado de la coerción es NaN o 0, entonces se buscará en todo el búfer. Este comportamiento coincide con String.prototype.indexOf().

ESM

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Pasando un valor que es un número, pero no un byte válido.
// Imprime: 2, equivalente a buscar 99 o 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Pasando un byteOffset que se fuerza a NaN o 0.
// Imprime: 1, buscando en todo el búfer.
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')

// Pasando un valor que es un número, pero no un byte válido.
// Imprime: 2, equivalente a buscar 99 o 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Pasando un byteOffset que se fuerza a NaN o 0.
// Imprime: 1, buscando en todo el búfer.
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))

Si value es una cadena vacía o un Buffer vacío y byteOffset es menor que buf.length, se devolverá byteOffset. Si value está vacío y byteOffset es al menos buf.length, se devolverá buf.length.

buf.keys()

Añadido en: v1.1.0

• Devuelve: <Iterator>

Crea y devuelve un iterador de las claves (índices) de buf.

ESM

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

CJS

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])

[Historial]

Versión	Cambios
v8.0.0	El value ahora puede ser un Uint8Array.
v6.0.0	Añadido en: v6.0.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Qué buscar.
• byteOffset <integer> Dónde comenzar la búsqueda en buf. Si es negativo, el desplazamiento se calcula desde el final de buf. Predeterminado: buf.length - 1.
• encoding <string> Si value es una cadena, esta es la codificación utilizada para determinar la representación binaria de la cadena que se buscará en buf. Predeterminado: 'utf8'.
• Devuelve: <integer> El índice de la última aparición de value en buf, o -1 si buf no contiene value.

Idéntico a buf.indexOf(), excepto que se encuentra la última aparición de value en lugar de la primera.

ESM

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 es el 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

CJS

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 es el 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

Si value no es una cadena, un número o un Buffer, este método lanzará un TypeError. Si value es un número, se convertirá a un valor de byte válido, un entero entre 0 y 255.

Si byteOffset no es un número, se convertirá a un número. Cualquier argumento que se convierta a NaN, como {} o undefined, buscará en todo el búfer. Este comportamiento coincide con String.prototype.lastIndexOf().

ESM

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Pasando un valor que es un número, pero no un byte válido.
// Imprime: 2, equivalente a buscar 99 o 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Pasando un byteOffset que se convierte a NaN.
// Imprime: 1, buscando en todo el búfer.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Pasando un byteOffset que se convierte a 0.
// Imprime: -1, equivalente a pasar 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

CJS

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

const b = Buffer.from('abcdef')

// Pasando un valor que es un número, pero no un byte válido.
// Imprime: 2, equivalente a buscar 99 o 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Pasando un byteOffset que se convierte a NaN.
// Imprime: 1, buscando en todo el búfer.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Pasando un byteOffset que se convierte a 0.
// Imprime: -1, equivalente a pasar 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

Si value es una cadena vacía o un Buffer vacío, se devolverá byteOffset.

buf.length

Añadido en: v0.1.90

• <integer>

Devuelve el número de bytes en buf.

ESM

import { Buffer } from 'node:buffer'

// Crea un `Buffer` y escribe una cadena más corta usando UTF-8.

const buf = Buffer.alloc(1234)

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

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

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

CJS

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

// Crea un `Buffer` y escribe una cadena más corta usando UTF-8.

const buf = Buffer.alloc(1234)

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

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

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

buf.parent

En desuso desde: v8.0.0

[Estable: 0 - En desuso]

Estable: 0 Estabilidad: 0 - En desuso: Use buf.buffer en su lugar.

La propiedad buf.parent es un alias en desuso para buf.buffer.

buf.readBigInt64BE([offset])

Añadido en: v12.0.0, v10.20.0

• offset <integer> Número de bytes que se omitirán antes de comenzar a leer. Debe satisfacer: 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <bigint>

Lee un entero con signo de 64 bits, big-endian, desde buf en el offset especificado.

Los enteros leídos desde un Buffer se interpretan como valores con signo de complemento a dos.

buf.readBigInt64LE([offset])

Añadido en: v12.0.0, v10.20.0

• offset <integer> Número de bytes que se omitirán antes de comenzar a leer. Debe satisfacer: 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <bigint>

Lee un entero con signo de 64 bits, little-endian, desde buf en el offset especificado.

Los enteros leídos desde un Buffer se interpretan como valores con signo de complemento a dos.

buf.readBigUInt64BE([offset])

[Historial]

Versión	Cambios
v14.10.0, v12.19.0	Esta función también está disponible como buf.readBigUint64BE().
v12.0.0, v10.20.0	Añadido en: v12.0.0, v10.20.0

• offset <integer> Número de bytes que se omitirán antes de comenzar a leer. Debe cumplir: 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <bigint>

Lee un entero de 64 bits sin signo, de orden de bytes big-endian, desde buf en el offset especificado.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v14.10.0, v12.19.0	Esta función también está disponible como buf.readBigUint64LE().
v12.0.0, v10.20.0	Añadido en: v12.0.0, v10.20.0

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer: 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <bigint>

Lee un entero de 64 bits sin signo y de orden little-endian desde buf en el offset especificado.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.11.15	Añadido en: v0.11.15

• offset <integer> Número de bytes que se omitirán antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <number>

Lee un doble de 64 bits, big-endian, de buf en el desplazamiento 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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.11.15	Añadido en: v0.11.15

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <number>

Lee un doble de 64 bits, little-endian de buf en el desplazamiento 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))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readFloatBE([offset])

[Historial]

Versión	Cambios
v10.0.0	Se eliminó noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.11.15	Añadido en: v0.11.15

• offset <integer> Número de bytes que se omitirán antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <number>

Lee un flotante de 32 bits, big-endian, de buf en el 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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminó noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.11.15	Añadido en: v0.11.15

• offset <integer> Número de bytes que se omitirán antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <number>

Lee un flotante de 32 bits, little-endian, de buf en el 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))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readInt8([offset])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.0	Añadido en: v0.5.0

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 1. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero con signo de 8 bits de buf en el desplazamiento especificado.

Los enteros leídos de un Buffer se interpretan como valores con signo de complemento a dos.

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))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readInt16BE([offset])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 2. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero con signo de 16 bits, big-endian, de buf en el desplazamiento especificado.

Los enteros leídos de un Buffer se interpretan como valores con signo de complemento a dos.

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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe cumplir 0 \<= offset \<= buf.length - 2. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero de 16 bits con signo y orden de bytes little-endian desde buf en el desplazamiento especificado.

Los enteros leídos de un Buffer se interpretan como valores con signo de complemento a dos.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt16LE(0))
// Imprime: 1280
console.log(buf.readInt16LE(1))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readInt32BE([offset])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero con signo de 32 bits, big-endian, de buf en el offset especificado.

Los enteros leídos de un Buffer se interpretan como valores con signo de complemento a dos.

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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero de 32 bits con signo y orden little-endian desde buf en el offset especificado.

Los enteros leídos desde un Buffer se interpretan como valores con signo de complemento a dos.

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))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readIntBE(offset, byteLength)

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita de offset y byteLength a uint32.
v0.11.15	Añadido en: v0.11.15

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes que se deben leer. Debe satisfacer 0 \< byteLength \<= 6.
• Devuelve: <integer>

Lee byteLength bytes de buf en el offset especificado e interpreta el resultado como un valor entero con signo big-endian, de complemento a dos, que admite hasta 48 bits de precisión.

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))
// Lanza ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Lanza ERR_OUT_OF_RANGE.

buf.readIntLE(offset, byteLength)

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita de offset y byteLength a uint32.
v0.11.15	Añadido en: v0.11.15

• offset <integer> Número de bytes que se omitirán antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes que se leerán. Debe satisfacer 0 \< byteLength \<= 6.
• Devuelve: <integer>

Lee byteLength bytes de buf en el offset especificado e interpreta el resultado como un valor con signo de complemento a dos, little-endian, que admite hasta 48 bits de precisión.

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])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.readUint8().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.0	Añadido en: v0.5.0

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 1. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero sin signo de 8 bits de buf en el desplazamiento especificado.

Esta función también está disponible bajo el 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))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readUInt16BE([offset])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.readUint16BE().
v10.0.0	Se eliminaron noAssert y la coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 2. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero sin signo de 16 bits, de orden de bytes big-endian, desde buf en el desplazamiento especificado.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.readUint16LE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 2. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero de 16 bits sin signo, little-endian, de buf en el desplazamiento especificado.

Esta función también está disponible bajo el 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))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readUInt32BE([offset])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.readUint32BE().
v10.0.0	Se eliminaron noAssert y la coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero de 32 bits sin signo y de orden de bytes big-endian desde buf en el offset especificado.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.readUint32LE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe cumplir 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer>

Lee un entero de 32 bits sin signo, little-endian, desde buf en el offset especificado.

Esta función también está disponible bajo el 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))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readUIntBE(offset, byteLength)

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.readUintBE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento y byteLength a uint32.
v0.11.15	Añadido en: v0.11.15

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe cumplir con 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes que se deben leer. Debe cumplir con 0 \< byteLength \<= 6.
• Devuelve: <integer>

Lee byteLength bytes de buf en el offset especificado e interpreta el resultado como un entero sin signo big-endian con soporte para hasta 48 bits de precisión.

Esta función también está disponible bajo el 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))
// Lanza 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))
// Lanza ERR_OUT_OF_RANGE.

buf.readUIntLE(offset, byteLength)

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.readUintLE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento y byteLength a uint32.
v0.11.15	Añadido en: v0.11.15

• offset <integer> Número de bytes que se deben omitir antes de comenzar a leer. Debe cumplir 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes que se deben leer. Debe cumplir 0 \< byteLength \<= 6.
• Devuelve: <integer>

Lee byteLength bytes de buf en el offset especificado e interpreta el resultado como un entero sin signo, little-endian, que admite hasta 48 bits de precisión.

Esta función también está disponible bajo el 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]])

Añadido en: v3.0.0

• start <integer> Donde comenzará el nuevo Buffer. Predeterminado: 0.
• end <integer> Donde terminará el nuevo Buffer (no inclusivo). Predeterminado: buf.length.
• Devuelve: <Buffer>

Devuelve un nuevo Buffer que referencia la misma memoria que el original, pero desplazado y recortado por los índices start y end.

Especificar end mayor que buf.length devolverá el mismo resultado que end igual a buf.length.

Este método se hereda de TypedArray.prototype.subarray().

Modificar la nueva porción Buffer modificará la memoria en el Buffer original porque la memoria asignada de los dos objetos se superpone.

ESM

import { Buffer } from 'node:buffer'

// Crea un `Buffer` con el alfabeto ASCII, toma una porción y modifica un byte
// del `Buffer` original.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 es el valor ASCII decimal 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')

// Crea un `Buffer` con el alfabeto ASCII, toma una porción y modifica un byte
// del `Buffer` original.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 es el valor ASCII decimal 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 hace que la porción se genere en relación con el final de buf en lugar del principio.

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]])

[Historial]

Versión	Cambios
v17.5.0, v16.15.0	El método buf.slice() ha sido desaprobado.
v7.0.0	Todos los desplazamientos ahora se convierten a enteros antes de realizar cualquier cálculo con ellos.
v7.1.0, v6.9.2	La conversión de los desplazamientos a enteros ahora maneja correctamente los valores fuera del rango de enteros de 32 bits.
v0.3.0	Añadido en: v0.3.0

• start <integer> Donde comenzará el nuevo Buffer. Predeterminado: 0.
• end <integer> Donde terminará el nuevo Buffer (no inclusivo). Predeterminado: buf.length.
• Devuelve: <Buffer>

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto: Use buf.subarray en su lugar.

Devuelve un nuevo Buffer que hace referencia a la misma memoria que el original, pero desplazado y recortado por los índices start y end.

Este método no es compatible con Uint8Array.prototype.slice(), que es una superclase de Buffer. Para copiar la porción, 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

// Con buf.slice(), el buffer original se modifica.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Imprime: cuffer
console.log(buf.toString())
// También 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

// Con buf.slice(), el buffer original se modifica.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Imprime: cuffer
console.log(buf.toString())
// También imprime: cuffer (!)

buf.swap16()

Añadido en: v5.10.0

• Devuelve: <Buffer> Una referencia a buf.

Interpreta buf como un array de enteros sin signo de 16 bits y cambia el orden de bytes in situ. Lanza ERR_INVALID_BUFFER_SIZE si buf.length no es 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()
// Lanza 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()
// Lanza ERR_INVALID_BUFFER_SIZE.

Un uso conveniente de buf.swap16() es realizar una conversión rápida in situ entre UTF-16 little-endian y UTF-16 big-endian:

ESM

import { Buffer } from 'node:buffer'

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

CJS

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

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

buf.swap32()

Añadido en: v5.10.0

• Devuelve: <Buffer> Una referencia a buf.

Interpreta buf como un array de enteros sin signo de 32 bits y cambia el orden de los bytes in-place. Lanza ERR_INVALID_BUFFER_SIZE si buf.length no es 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()
// Lanza 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()
// Lanza ERR_INVALID_BUFFER_SIZE.

buf.swap64()

Añadido en: v6.3.0

• Devuelve: <Buffer> Una referencia a buf.

Interpreta buf como un array de números de 64 bits e intercambia el orden de los bytes in-place. Lanza ERR_INVALID_BUFFER_SIZE si buf.length no es 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()
// Lanza 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()
// Lanza ERR_INVALID_BUFFER_SIZE.

buf.toJSON()

Añadido en: v0.9.2

• Devuelve: <Object>

Devuelve una representación JSON de buf. JSON.stringify() llama implícitamente a esta función cuando se convierte una instancia de Buffer en una cadena.

Buffer.from() acepta objetos en el formato devuelto por este método. En 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]]])

Añadido en: v0.1.90

• encoding <string> La codificación de caracteres a utilizar. Predeterminado: 'utf8'.
• start <integer> El desplazamiento de bytes donde comenzar la decodificación. Predeterminado: 0.
• end <integer> El desplazamiento de bytes donde detener la decodificación (no inclusivo). Predeterminado: buf.length.
• Devuelve: <string>

Decodifica buf a una cadena según la codificación de caracteres especificada en encoding. Se pueden pasar start y end para decodificar solo un subconjunto de buf.

Si encoding es 'utf8' y una secuencia de bytes en la entrada no es UTF-8 válida, cada byte inválido se reemplaza con el carácter de reemplazo U+FFFD.

La longitud máxima de una instancia de cadena (en unidades de código UTF-16) está disponible 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 es el 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 es el 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()

Añadido en: v1.1.0

• Devuelve: <Iterator>

Crea y devuelve un iterador para los valores (bytes) de buf. Esta función se llama automáticamente cuando un Buffer se usa en una sentencia 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])

Añadido en: v0.1.90

• string <string> Cadena a escribir en buf.
• offset <integer> Número de bytes que se deben omitir antes de comenzar a escribir string. Predeterminado: 0.
• length <integer> Número máximo de bytes a escribir (los bytes escritos no excederán buf.length - offset). Predeterminado: buf.length - offset.
• encoding <string> Codificación de caracteres de string. Predeterminado: 'utf8'.
• Devuelve: <integer> Número de bytes escritos.

Escribe string en buf en offset según la codificación de caracteres en encoding. El parámetro length es el número de bytes a escribir. Si buf no contuviera espacio suficiente para toda la cadena, solo se escribirá parte de string. Sin embargo, no se escribirán caracteres parcialmente codificados.

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(value[, offset])

Añadido en: v12.0.0, v10.20.0

• value <bigint> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe cumplir: 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como big-endian.

value se interpreta y escribe como un entero con signo en complemento a dos.

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(value[, offset])

Añadido en: v12.0.0, v10.20.0

• value <bigint> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer: 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como little-endian.

value se interpreta y escribe como un entero con signo de complemento a dos.

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])

[Historial]

Versión	Cambios
v14.10.0, v12.19.0	Esta función también está disponible como buf.writeBigUint64BE().
v12.0.0, v10.20.0	Añadido en: v12.0.0, v10.20.0

• value <bigint> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer: 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como big-endian.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v14.10.0, v12.19.0	Esta función también está disponible como buf.writeBigUint64LE().
v12.0.0, v10.20.0	Añadida en: v12.0.0, v10.20.0

• value <bigint> Número que se escribirá en buf.
• offset <integer> Número de bytes que se deben omitir antes de comenzar a escribir. Debe cumplir: 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el 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 función también está disponible bajo el alias writeBigUint64LE.

buf.writeDoubleBE(value[, offset])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.11.15	Añadido en: v0.11.15

• value <number> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como big-endian. El value debe ser un número de JavaScript. El comportamiento no está definido cuando value es cualquier cosa que no sea un número de 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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.11.15	Añadido en: v0.11.15

• value <número> Número que se escribirá en buf.
• offset <entero> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 8. Predeterminado: 0.
• Devuelve: <entero> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como little-endian. El value debe ser un número de JavaScript. El comportamiento no está definido cuando value es cualquier cosa que no sea un número de 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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.11.15	Añadido en: v0.11.15

• value <number> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe cumplir 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como big-endian. El comportamiento no está definido cuando value es cualquier cosa que no sea un número de 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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminó noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.11.15	Añadido en: v0.11.15

• value <número> Número que se escribirá en buf.
• offset <entero> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <entero> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como little-endian. El comportamiento no está definido cuando value es cualquier cosa que no sea un número de 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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.0	Añadido en: v0.5.0

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 1. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado. value debe ser un entero con signo válido de 8 bits. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero con signo de 8 bits.

value se interpreta y escribe como un entero con signo de complemento a dos.

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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 2. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como big-endian. El value debe ser un entero con signo de 16 bits válido. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero con signo de 16 bits.

El value se interpreta y escribe como un entero con signo de complemento a dos.

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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminó noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 2. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como little-endian. El value debe ser un entero con signo válido de 16 bits. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero con signo de 16 bits.

El value se interpreta y escribe como un entero con signo de complemento a dos.

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])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como big-endian. El value debe ser un entero con signo de 32 bits válido. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero con signo de 32 bits.

El value se interpreta y escribe como un entero con signo de complemento a dos.

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(value[, offset])

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como little-endian. El value debe ser un entero con signo de 32 bits válido. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero con signo de 32 bits.

El value se interpreta y escribe como un entero con signo de complemento a dos.

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(value, offset, byteLength)

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita de offset y byteLength a uint32.
v0.11.15	Añadido en: v0.11.15

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes que se escribirán. Debe satisfacer 0 \< byteLength \<= 6.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe byteLength bytes de value en buf en el offset especificado como big-endian. Admite hasta 48 bits de precisión. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero con signo.

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)

[Historial]

Versión	Cambios
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita de offset y byteLength a uint32.
v0.11.15	Añadido en: v0.11.15

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes que se escribirán. Debe satisfacer 0 \< byteLength \<= 6.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe byteLength bytes de value en buf en el offset especificado como little-endian. Admite hasta 48 bits de precisión. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero con signo.

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])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.writeUint8().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.0	Añadido en: v0.5.0

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 1. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado. value debe ser un entero sin signo válido de 8 bits. El comportamiento no está definido cuando value es cualquier otra cosa que no sea un entero sin signo de 8 bits.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.writeUint16BE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 2. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como big-endian. El value debe ser un entero sin signo válido de 16 bits. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero sin signo de 16 bits.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.writeUint16LE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 2. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como little-endian. El value debe ser un entero sin signo válido de 16 bits. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero sin signo de 16 bits.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.writeUint32BE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como big-endian. El value debe ser un entero sin signo válido de 32 bits. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero sin signo de 32 bits.

Esta función también está disponible bajo el 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])

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.writeUint32LE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - 4. Predeterminado: 0.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe value en buf en el offset especificado como little-endian. El value debe ser un entero sin signo válido de 32 bits. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero sin signo de 32 bits.

Esta función también está disponible bajo el 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)

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.writeUintBE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento y byteLength a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes que se escribirán. Debe satisfacer 0 \< byteLength \<= 6.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe byteLength bytes de value en buf en el offset especificado como big-endian. Admite hasta 48 bits de precisión. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero sin signo.

Esta función también está disponible bajo el 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)

[Historial]

Versión	Cambios
v14.9.0, v12.19.0	Esta función también está disponible como buf.writeUintLE().
v10.0.0	Se eliminaron noAssert y ya no hay coerción implícita del desplazamiento y byteLength a uint32.
v0.5.5	Añadido en: v0.5.5

• value <integer> Número que se escribirá en buf.
• offset <integer> Número de bytes que se omitirán antes de comenzar a escribir. Debe satisfacer 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Número de bytes que se escribirán. Debe satisfacer 0 \< byteLength \<= 6.
• Devuelve: <integer> offset más el número de bytes escritos.

Escribe byteLength bytes de value en buf en el offset especificado como little-endian. Admite hasta 48 bits de precisión. El comportamiento no está definido cuando value es cualquier cosa que no sea un entero sin signo.

Esta función también está disponible bajo el 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)

[Historial]

Versión	Cambios
v10.0.0	Llamar a este constructor emite una advertencia de deprecación cuando se ejecuta desde código fuera del directorio node_modules.
v7.2.1	Llamar a este constructor ya no emite una advertencia de deprecación.
v7.0.0	Llamar a este constructor emite ahora una advertencia de deprecación.
v6.0.0	Obsoleto desde: v6.0.0

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto: Use Buffer.from(array) en su lugar.

• array <integer[]> Una matriz de bytes para copiar desde.

Ver Buffer.from(array).

new Buffer(arrayBuffer[, byteOffset[, length]])

[Historial]

Versión	Cambios
v10.0.0	Llamar a este constructor emite una advertencia de deprecación cuando se ejecuta desde código fuera del directorio node_modules.
v7.2.1	Llamar a este constructor ya no emite una advertencia de deprecación.
v7.0.0	Llamar a este constructor emite ahora una advertencia de deprecación.
v6.0.0	Los parámetros byteOffset y length ahora son compatibles.
v6.0.0	Obsoleto desde: v6.0.0
v3.0.0	Añadido en: v3.0.0

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto: Use Buffer.from(arrayBuffer[, byteOffset[, length]]) en su lugar.

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Un ArrayBuffer, SharedArrayBuffer o la propiedad .buffer de un TypedArray.
• byteOffset <integer> Índice del primer byte que se va a exponer. Predeterminado: 0.
• length <integer> Número de bytes que se van a exponer. Predeterminado: arrayBuffer.byteLength - byteOffset.

Ver Buffer.from(arrayBuffer[, byteOffset[, length]]).

new Buffer(buffer)

[Historial]

Versión	Cambios
v10.0.0	Llamar a este constructor emite una advertencia de deprecación cuando se ejecuta desde código fuera del directorio node_modules.
v7.2.1	Llamar a este constructor ya no emite una advertencia de deprecación.
v7.0.0	Llamar a este constructor ahora emite una advertencia de deprecación.
v6.0.0	Obsoleto desde: v6.0.0

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto: Use Buffer.from(buffer) en su lugar.

• buffer <Buffer> | <Uint8Array> Un Buffer o Uint8Array existente desde el cual copiar datos.

Ver Buffer.from(buffer).

new Buffer(size)

[Historial]

Versión	Cambios
v10.0.0	Llamar a este constructor emite una advertencia de deprecación cuando se ejecuta desde código fuera del directorio node_modules.
v8.0.0	new Buffer(size) devolverá memoria llena de ceros por defecto.
v7.2.1	Llamar a este constructor ya no emite una advertencia de deprecación.
v7.0.0	Llamar a este constructor ahora emite una advertencia de deprecación.
v6.0.0	Obsoleto desde: v6.0.0

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto: Use Buffer.alloc() en su lugar (vea también Buffer.allocUnsafe()).

• size <entero> La longitud deseada del nuevo Buffer.

Consulte Buffer.alloc() y Buffer.allocUnsafe(). Esta variante del constructor es equivalente a Buffer.alloc().

new Buffer(string[, encoding])

[Historial]

Versión	Cambios
v10.0.0	Llamar a este constructor emite una advertencia de deprecación cuando se ejecuta desde código fuera del directorio node_modules.
v7.2.1	Llamar a este constructor ya no emite una advertencia de deprecación.
v7.0.0	Llamar a este constructor ahora emite una advertencia de deprecación.
v6.0.0	Obsoleto desde: v6.0.0

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto: Use Buffer.from(string[, encoding]) en su lugar.

• string <string> Cadena a codificar.
• encoding <string> La codificación de string. Predeterminado: 'utf8'.

Ver Buffer.from(string[, encoding]).

Clase: File

[Historial]

Versión	Cambios
v23.0.0	Hace que las instancias de File sean clonables.
v20.0.0	Ya no es experimental.
v19.2.0, v18.13.0	Añadido en: v19.2.0, v18.13.0

• Extiende: <Blob>

Un File proporciona información sobre archivos.

new buffer.File(sources, fileName[, options])

Añadido en: v19.2.0, v18.13.0

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> | <File[]> Un array de objetos string, <ArrayBuffer>, <TypedArray>, <DataView>, <File> o <Blob>, o cualquier mezcla de dichos objetos, que se almacenarán dentro del File.
• fileName <string> El nombre del archivo.
• options <Object>
  • endings <string> Uno de 'transparent' o 'native'. Cuando se establece en 'native', los saltos de línea en las partes de origen de la cadena se convertirán al salto de línea nativo de la plataforma según lo especifique require('node:os').EOL.
  • type <string> El tipo de contenido del archivo.
  • lastModified <number> La fecha de última modificación del archivo. Predeterminado: Date.now().

file.name

Añadido en: v19.2.0, v18.13.0

• Tipo: <string>

El nombre del File.

file.lastModified

Añadido en: v19.2.0, v18.13.0

• Tipo: <number>

La fecha de última modificación del File.

APIs del módulo node:buffer

Si bien el objeto Buffer está disponible como global, hay APIs adicionales relacionadas con Buffer que solo están disponibles a través del módulo node:buffer al que se accede usando require('node:buffer').

buffer.atob(data)

Añadido en: v15.13.0, v14.17.0

[Estable: 3 - Legado]

Estable: 3 Estabilidad: 3 - Legado. Usar Buffer.from(data, 'base64') en su lugar.

• data <any> La cadena de entrada codificada en Base64.

Decodifica una cadena de datos codificados en Base64 en bytes y codifica esos bytes en una cadena usando Latin-1 (ISO-8859-1).

data puede ser cualquier valor de JavaScript que pueda convertirse en una cadena.

Esta función solo se proporciona para compatibilidad con las API de la plataforma web heredadas y nunca debe usarse en código nuevo, ya que utilizan cadenas para representar datos binarios y son anteriores a la introducción de matrices tipadas en JavaScript. Para el código que se ejecuta usando las API de Node.js, la conversión entre cadenas codificadas en base64 y datos binarios debe realizarse usando Buffer.from(str, 'base64') y buf.toString('base64').

buffer.btoa(data)

Añadido en: v15.13.0, v14.17.0

[Estable: 3 - Heredado]

Estable: 3 Estabilidad: 3 - Heredado. Usar buf.toString('base64') en su lugar.

• data <cualquiera> Una cadena ASCII (Latin1).

Decodifica una cadena en bytes usando Latin-1 (ISO-8859), y codifica esos bytes en una cadena usando Base64.

data puede ser cualquier valor JavaScript que pueda ser forzado a una cadena.

Esta función solo se proporciona para compatibilidad con las API heredadas de la plataforma web y nunca debe usarse en código nuevo, ya que usan cadenas para representar datos binarios y son anteriores a la introducción de matrices tipadas en JavaScript. Para el código que se ejecuta usando las API de Node.js, la conversión entre cadenas codificadas en base64 y datos binarios debe realizarse usando Buffer.from(str, 'base64') y buf.toString('base64').

buffer.isAscii(input)

Añadido en: v19.6.0, v18.15.0

• input <Buffer> | <ArrayBuffer> | <TypedArray> La entrada a validar.
• Devuelve: <booleano>

Esta función devuelve true si input contiene solo datos codificados en ASCII válidos, incluyendo el caso en que input está vacío.

Lanza una excepción si la input es un array buffer separado.

buffer.isUtf8(input)

Añadido en: v19.4.0, v18.14.0

• input <Buffer> | <ArrayBuffer> | <TypedArray> La entrada a validar.
• Devuelve: <boolean>

Esta función devuelve true si input contiene solo datos codificados en UTF-8 válidos, incluyendo el caso en que input está vacío.

Lanza una excepción si input es un ArrayBuffer separado.

buffer.INSPECT_MAX_BYTES

Añadido en: v0.5.4

• <integer> Predeterminado: 50

Devuelve el número máximo de bytes que se devolverán cuando se llame a buf.inspect(). Esto puede ser anulado por módulos de usuario. Consulte util.inspect() para obtener más detalles sobre el comportamiento de buf.inspect().

buffer.kMaxLength

Añadido en: v3.0.0

• <integer> El tamaño máximo permitido para una única instancia de Buffer.

Un alias para buffer.constants.MAX_LENGTH.

buffer.kStringMaxLength

Añadido en: v3.0.0

• <integer> La longitud máxima permitida para una única instancia de string.

Un alias para buffer.constants.MAX_STRING_LENGTH.

buffer.resolveObjectURL(id)

Añadido en: v16.7.0

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1 - Experimental

• id <string> Una cadena de URL 'blob:nodedata:... devuelta por una llamada anterior a URL.createObjectURL().
• Devuelve: <Blob>

Resuelve un 'blob:nodedata:...' en un objeto <Blob> asociado registrado usando una llamada anterior a URL.createObjectURL().

buffer.transcode(source, fromEnc, toEnc)

[Historial]

Versión	Cambios
v8.0.0	El parámetro source ahora puede ser un Uint8Array.
v7.1.0	Añadido en: v7.1.0

• source <Buffer> | <Uint8Array> Una instancia de Buffer o Uint8Array.
• fromEnc <string> La codificación actual.
• toEnc <string> La codificación de destino.
• Devuelve: <Buffer>

Re-codifica la instancia dada de Buffer o Uint8Array de una codificación de caracteres a otra. Devuelve una nueva instancia de Buffer.

Lanza una excepción si fromEnc o toEnc especifican codificaciones de caracteres inválidas o si la conversión de fromEnc a toEnc no está permitida.

Las codificaciones soportadas por buffer.transcode() son: 'ascii', 'utf8', 'utf16le', 'ucs2', 'latin1', y 'binary'.

El proceso de transcodificación usará caracteres de sustitución si una secuencia de bytes dada no puede ser representada adecuadamente en la codificación de destino. Por ejemplo:

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: '?'

Debido a que el símbolo del Euro (€) no es representable en US-ASCII, es reemplazado con ? en el Buffer transcodificado.

Clase: SlowBuffer

En desuso desde: v6.0.0

[Estable: 0 - En desuso]

Estable: 0 Estabilidad: 0 - En desuso: Use Buffer.allocUnsafeSlow() en su lugar.

Ver Buffer.allocUnsafeSlow(). Esto nunca fue una clase en el sentido de que el constructor siempre devolvía una instancia de Buffer, en lugar de una instancia de SlowBuffer.

new SlowBuffer(size)

En desuso desde: v6.0.0

[Estable: 0 - En desuso]

Estable: 0 Estabilidad: 0 - En desuso: Use Buffer.allocUnsafeSlow() en su lugar.

• size <integer> La longitud deseada del nuevo SlowBuffer.

Ver Buffer.allocUnsafeSlow().

Constantes de Buffer

Añadido en: v8.2.0

buffer.constants.MAX_LENGTH

[Historial]

Versión	Cambios
v22.0.0	El valor se cambia a 2 - 1 en arquitecturas de 64 bits.
v15.0.0	El valor se cambia a 2 en arquitecturas de 64 bits.
v14.0.0	El valor se cambia de 2 - 1 a 2 - 1 en arquitecturas de 64 bits.
v8.2.0	Añadido en: v8.2.0

• <entero> El tamaño máximo permitido para una sola instancia de Buffer.

En arquitecturas de 32 bits, este valor actualmente es 2 - 1 (aproximadamente 1 GiB).

En arquitecturas de 64 bits, este valor actualmente es 2 - 1 (aproximadamente 8 PiB).

Refleja v8::TypedArray::kMaxLength internamente.

Este valor también está disponible como buffer.kMaxLength.

buffer.constants.MAX_STRING_LENGTH

Añadido en: v8.2.0

• <entero> La longitud máxima permitida para una sola instancia de string.

Representa la longitud máxima que puede tener un primitivo string, contada en unidades de código UTF-16.

Este valor puede depender del motor JS que se esté utilizando.

Buffer.from(), Buffer.alloc() y Buffer.allocUnsafe()

En versiones de Node.js anteriores a la 6.0.0, las instancias de Buffer se creaban usando la función constructora Buffer, que asignaba el Buffer devuelto de manera diferente según los argumentos proporcionados:

• Pasar un número como primer argumento a Buffer() (por ejemplo, new Buffer(10)) asigna un nuevo objeto Buffer del tamaño especificado. Antes de Node.js 8.0.0, la memoria asignada para dichas instancias de Buffer no estaba inicializada y podía contener datos sensibles. Dichas instancias de Buffer deben inicializarse posteriormente usando buf.fill(0) o escribiendo en todo el Buffer antes de leer datos del Buffer. Si bien este comportamiento es intencional para mejorar el rendimiento, la experiencia de desarrollo ha demostrado que se requiere una distinción más explícita entre crear un Buffer rápido pero no inicializado versus crear un Buffer más lento pero más seguro. Desde Node.js 8.0.0, Buffer(num) y new Buffer(num) devuelven un Buffer con memoria inicializada.
• Pasar una cadena, una matriz o un Buffer como primer argumento copia los datos del objeto pasado en el Buffer.
• Pasar un ArrayBuffer o un SharedArrayBuffer devuelve un Buffer que comparte la memoria asignada con el array buffer dado.

Debido a que el comportamiento de new Buffer() es diferente según el tipo del primer argumento, se pueden introducir inadvertidamente problemas de seguridad y confiabilidad en las aplicaciones cuando no se realiza la validación de argumentos o la inicialización de Buffer.

Por ejemplo, si un atacante puede hacer que una aplicación reciba un número donde se espera una cadena, la aplicación puede llamar a new Buffer(100) en lugar de new Buffer("100"), lo que la lleva a asignar un buffer de 100 bytes en lugar de asignar un buffer de 3 bytes con el contenido "100". Esto es comúnmente posible usando llamadas a API JSON. Dado que JSON distingue entre tipos numéricos y de cadena, permite la inyección de números donde una aplicación escrita ingenuamente que no valida suficientemente su entrada podría esperar recibir siempre una cadena. Antes de Node.js 8.0.0, el buffer de 100 bytes podría contener datos arbitrarios preexistentes en la memoria, por lo que podría usarse para exponer secretos en la memoria a un atacante remoto. Desde Node.js 8.0.0, la exposición de memoria no puede ocurrir porque los datos se rellenan con ceros. Sin embargo, todavía son posibles otros ataques, como causar que el servidor asigne buffers muy grandes, lo que lleva a una degradación del rendimiento o a un fallo por agotamiento de memoria.

Para que la creación de instancias de Buffer sea más confiable y menos propensa a errores, las diversas formas del constructor new Buffer() han sido obsoletas y reemplazadas por los métodos separados Buffer.from(), Buffer.alloc() y Buffer.allocUnsafe().

Los desarrolladores deben migrar todos los usos existentes de los constructores new Buffer() a una de estas nuevas API.

• Buffer.from(array) devuelve un nuevo Buffer que contiene una copia de los octetos proporcionados.
• Buffer.from(arrayBuffer[, byteOffset[, length]]) devuelve un nuevo Buffer que comparte la misma memoria asignada que el ArrayBuffer dado.
• Buffer.from(buffer) devuelve un nuevo Buffer que contiene una copia del contenido del Buffer dado.
• Buffer.from(string[, encoding]) devuelve un nuevo Buffer que contiene una copia de la cadena proporcionada.
• Buffer.alloc(size[, fill[, encoding]]) devuelve un nuevo Buffer inicializado del tamaño especificado. Este método es más lento que Buffer.allocUnsafe(size) pero garantiza que las instancias de Buffer recién creadas nunca contengan datos antiguos que puedan ser sensibles. Se lanzará un TypeError si size no es un número.
• Buffer.allocUnsafe(size) y Buffer.allocUnsafeSlow(size) devuelven cada uno un nuevo Buffer no inicializado del size especificado. Debido a que el Buffer no está inicializado, el segmento de memoria asignado puede contener datos antiguos que pueden ser sensibles.

Las instancias de Buffer devueltas por Buffer.allocUnsafe(), Buffer.from(string), Buffer.concat() y Buffer.from(array) pueden asignarse de un grupo de memoria interna compartida si size es menor o igual a la mitad de Buffer.poolSize. Las instancias devueltas por Buffer.allocUnsafeSlow() nunca usan el grupo de memoria interna compartida.

La opción de línea de comandos --zero-fill-buffers

Añadido en: v5.10.0

Node.js puede iniciarse usando la opción de línea de comandos --zero-fill-buffers para que todas las instancias de Buffer recién asignadas se rellenen con ceros por defecto al crearse. Sin la opción, los buffers creados con Buffer.allocUnsafe(), Buffer.allocUnsafeSlow(), y new SlowBuffer(size) no se rellenan con ceros. El uso de esta bandera puede tener un impacto negativo medible en el rendimiento. Use la opción --zero-fill-buffers solo cuando sea necesario para garantizar que las instancias de Buffer recién asignadas no puedan contener datos antiguos que sean potencialmente sensibles.

$ node --zero-fill-buffers
> Buffer.allocUnsafe(5);
<Buffer 00 00 00 00 00>

¿Qué hace que Buffer.allocUnsafe() y Buffer.allocUnsafeSlow() sean "inseguros"?

Al llamar a Buffer.allocUnsafe() y Buffer.allocUnsafeSlow(), el segmento de memoria asignado está sin inicializar (no se pone a cero). Si bien este diseño hace que la asignación de memoria sea bastante rápida, el segmento de memoria asignado puede contener datos antiguos que sean potencialmente sensibles. El uso de un Buffer creado por Buffer.allocUnsafe() sin sobrescribir completamente la memoria puede permitir que estos datos antiguos se filtren cuando se lee la memoria del Buffer.

Si bien existen claras ventajas de rendimiento al usar Buffer.allocUnsafe(), se debe tener un cuidado especial para evitar introducir vulnerabilidades de seguridad en una aplicación.