Buffer

[Стабильно: 2 - Стабильно]

Стабильно: 2 Стабильность: 2 - Стабильно

Исходный код: lib/buffer.js

Объекты Buffer используются для представления последовательности байтов фиксированной длины. Многие API Node.js поддерживают Buffer.

Класс Buffer является подклассом JavaScript-класса Uint8Array и расширяет его методами, которые охватывают дополнительные варианты использования. API Node.js принимают простые Uint8Array, где также поддерживаются Buffer.

Хотя класс Buffer доступен в глобальной области видимости, по-прежнему рекомендуется явно ссылаться на него через оператор import или require.

ESM

import { Buffer } from 'node:buffer'

// Создает буфер, заполненный нулями, длиной 10.
const buf1 = Buffer.alloc(10)

// Создает буфер длиной 10,
// заполненный байтами, каждый из которых имеет значение `1`.
const buf2 = Buffer.alloc(10, 1)

// Создает неинициализированный буфер длиной 10.
// Это быстрее, чем вызов Buffer.alloc(), но возвращенный
// экземпляр Buffer может содержать старые данные, которые необходимо
// перезаписать с помощью fill(), write() или других функций, заполняющих содержимое буфера.
const buf3 = Buffer.allocUnsafe(10)

// Создает буфер, содержащий байты [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3])

// Создает буфер, содержащий байты [1, 1, 1, 1] – записи
// усекаются с помощью `(value & 255)`, чтобы поместиться в диапазон 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Создает буфер, содержащий байты в кодировке UTF-8 для строки 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (в шестнадцатеричном представлении)
// [116, 195, 169, 115, 116] (в десятичном представлении)
const buf6 = Buffer.from('tést')

// Создает буфер, содержащий байты Latin-1 [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1')

CJS

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

// Создает буфер, заполненный нулями, длиной 10.
const buf1 = Buffer.alloc(10)

// Создает буфер длиной 10,
// заполненный байтами, каждый из которых имеет значение `1`.
const buf2 = Buffer.alloc(10, 1)

// Создает неинициализированный буфер длиной 10.
// Это быстрее, чем вызов Buffer.alloc(), но возвращенный
// экземпляр Buffer может содержать старые данные, которые необходимо
// перезаписать с помощью fill(), write() или других функций, заполняющих содержимое буфера.
const buf3 = Buffer.allocUnsafe(10)

// Создает буфер, содержащий байты [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3])

// Создает буфер, содержащий байты [1, 1, 1, 1] – записи
// усекаются с помощью `(value & 255)`, чтобы поместиться в диапазон 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Создает буфер, содержащий байты в кодировке UTF-8 для строки 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (в шестнадцатеричном представлении)
// [116, 195, 169, 115, 116] (в десятичном представлении)
const buf6 = Buffer.from('tést')

// Создает буфер, содержащий байты Latin-1 [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1')

Буферы и кодировки символов

[История]

Версия	Изменения
v15.7.0, v14.18.0	Введена кодировка base64url.
v6.4.0	Введено latin1 как псевдоним для binary.
v5.0.0	Удалены устаревшие кодировки raw и raws.

При преобразовании между Buffer и строками может быть указана кодировка символов. Если кодировка символов не указана, то по умолчанию будет использоваться UTF-8.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.toString('hex'))
// Выводит: 68656c6c6f20776f726c64
console.log(buf.toString('base64'))
// Выводит: aGVsbG8gd29ybGQ=

console.log(Buffer.from('fhqwhgads', 'utf8'))
// Выводит: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'))
// Выводит: <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'))
// Выводит: 68656c6c6f20776f726c64
console.log(buf.toString('base64'))
// Выводит: aGVsbG8gd29ybGQ=

console.log(Buffer.from('fhqwhgads', 'utf8'))
// Выводит: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'))
// Выводит: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>

Буферы Node.js принимают все варианты регистра строк кодировки, которые они получают. Например, UTF-8 можно указать как 'utf8', 'UTF8' или 'uTf8'.

В настоящее время Node.js поддерживает следующие кодировки символов:

• 'utf8' (псевдоним: 'utf-8'): Многобайтовая кодировка символов Unicode. Многие веб-страницы и другие форматы документов используют UTF-8. Это кодировка символов по умолчанию. При декодировании Buffer в строку, которая не содержит исключительно допустимые данные UTF-8, для представления этих ошибок будет использоваться символ замены Unicode U+FFFD �.
• 'utf16le' (псевдоним: 'utf-16le'): Многобайтовая кодировка символов Unicode. В отличие от 'utf8', каждый символ в строке будет закодирован с использованием 2 или 4 байтов. Node.js поддерживает только малобитный вариант UTF-16.
• 'latin1': Latin-1 означает ISO-8859-1. Эта кодировка символов поддерживает только символы Unicode от U+0000 до U+00FF. Каждый символ кодируется с помощью одного байта. Символы, которые не попадают в этот диапазон, обрезаются и будут сопоставлены с символами в этом диапазоне.

Преобразование Buffer в строку с использованием одного из вышеперечисленных называется декодированием, а преобразование строки в Buffer называется кодированием.

Node.js также поддерживает следующие кодировки двоичных данных в текст. Для кодировок двоичных данных в текст соглашение об именовании изменено: Преобразование Buffer в строку обычно называется кодированием, а преобразование строки в Buffer - декодированием.

• 'base64': Кодировка Base64. При создании Buffer из строки эта кодировка также правильно примет "URL и Filename Safe Alphabet", как указано в RFC 4648, раздел 5. Символы пробелов, такие как пробелы, табуляции и новые строки, содержащиеся в строке, закодированной в base64, игнорируются.
• 'base64url': Кодировка base64url, как указано в RFC 4648, раздел 5. При создании Buffer из строки эта кодировка также правильно примет обычные строки, закодированные в base64. При кодировании Buffer в строку эта кодировка будет опускать заполнение.
• 'hex': Кодирует каждый байт как два шестнадцатеричных символа. Усечение данных может произойти при декодировании строк, которые не состоят исключительно из четного числа шестнадцатеричных символов. Смотрите пример ниже.

Также поддерживаются следующие устаревшие кодировки символов:

• 'ascii': Только для 7-битных данных ASCII. При кодировании строки в Buffer это эквивалентно использованию 'latin1'. При декодировании Buffer в строку с использованием этой кодировки дополнительно будет снят старший бит каждого байта перед декодированием как 'latin1'. Как правило, нет причин использовать эту кодировку, поскольку 'utf8' (или, если известно, что данные всегда являются только ASCII, 'latin1') будет лучшим выбором при кодировании или декодировании текста только ASCII. Она предоставляется только для обеспечения совместимости со старыми версиями.
• 'binary': Псевдоним для 'latin1'. Название этой кодировки может быть очень обманчивым, так как все перечисленные здесь кодировки преобразуют строки и двоичные данные. Для преобразования между строками и Buffer обычно подходит 'utf8'.
• 'ucs2', 'ucs-2': Псевдонимы 'utf16le'. UCS-2 раньше относилась к варианту UTF-16, который не поддерживал символы, имеющие кодовые точки больше, чем U+FFFF. В Node.js эти кодовые точки всегда поддерживаются.

ESM

import { Buffer } from 'node:buffer'

Buffer.from('1ag123', 'hex')
// Выводит <Buffer 1a>, данные усечены при первом обнаружении нешестнадцатеричного значения
// ('g').

Buffer.from('1a7', 'hex')
// Выводит <Buffer 1a>, данные усечены, когда данные заканчиваются на одну цифру ('7').

Buffer.from('1634', 'hex')
// Выводит <Buffer 16 34>, все данные представлены.

CJS

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

Buffer.from('1ag123', 'hex')
// Выводит <Buffer 1a>, данные усечены при первом обнаружении нешестнадцатеричного значения
// ('g').

Buffer.from('1a7', 'hex')
// Выводит <Buffer 1a>, данные усечены, когда данные заканчиваются на одну цифру ('7').

Buffer.from('1634', 'hex')
// Выводит <Buffer 16 34>, все данные представлены.

Современные веб-браузеры следуют стандарту кодирования WHATWG, который присваивает псевдонимы 'latin1' и 'ISO-8859-1' к 'win-1252'. Это означает, что при выполнении чего-либо вроде http.get(), если возвращаемая кодировка является одной из перечисленных в спецификации WHATWG, возможно, что сервер фактически вернул данные в кодировке 'win-1252', и использование кодировки 'latin1' может неправильно декодировать символы.

Буферы и типизированные массивы

[История]

Версия	Изменения
v3.0.0	Класс Buffer теперь наследуется от Uint8Array.

Экземпляры Buffer также являются экземплярами JavaScript Uint8Array и TypedArray. Все методы TypedArray доступны для Buffer. Однако существуют небольшие несовместимости между API Buffer и API TypedArray.

В частности:

• В то время как TypedArray.prototype.slice() создает копию части TypedArray, Buffer.prototype.slice() создает представление существующего Buffer без копирования. Такое поведение может удивить и существует только для совместимости со старым кодом. TypedArray.prototype.subarray() может использоваться для достижения поведения Buffer.prototype.slice() как для Buffer, так и для других TypedArray, и его следует предпочесть.
• buf.toString() несовместим со своим эквивалентом TypedArray.
• Ряд методов, например, buf.indexOf(), поддерживают дополнительные аргументы.

Существует два способа создания новых экземпляров TypedArray из Buffer:

• Передача Buffer в конструктор TypedArray скопирует содержимое Buffer, интерпретированное как массив целых чисел, а не как последовательность байтов целевого типа.

ESM

import { Buffer } from 'node:buffer'

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

console.log(uint32array)

// Выводит: 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)

// Выводит: Uint32Array(4) [ 1, 2, 3, 4 ]

• Передача базового ArrayBuffer Buffer создаст TypedArray, который будет совместно использовать свою память с 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)

// Выводит: 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)

// Выводит: Uint16Array(5) [ 104, 101, 108, 108, 111 ]

Можно создать новый Buffer, который будет совместно использовать ту же выделенную память, что и экземпляр TypedArray, используя свойство .buffer объекта TypedArray аналогичным образом. Buffer.from() в этом контексте ведет себя как new Uint8Array().

ESM

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

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

// Копирует содержимое `arr`.
const buf1 = Buffer.from(arr)

// Разделяет память с `arr`.
const buf2 = Buffer.from(arr.buffer)

console.log(buf1)
// Выводит: <Buffer 88 a0>
console.log(buf2)
// Выводит: <Buffer 88 13 a0 0f>

arr[1] = 6000

console.log(buf1)
// Выводит: <Buffer 88 a0>
console.log(buf2)
// Выводит: <Buffer 88 13 70 17>

CJS

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

const arr = new Uint16Array(2)

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

// Копирует содержимое `arr`.
const buf1 = Buffer.from(arr)

// Разделяет память с `arr`.
const buf2 = Buffer.from(arr.buffer)

console.log(buf1)
// Выводит: <Buffer 88 a0>
console.log(buf2)
// Выводит: <Buffer 88 13 a0 0f>

arr[1] = 6000

console.log(buf1)
// Выводит: <Buffer 88 a0>
console.log(buf2)
// Выводит: <Buffer 88 13 70 17>

При создании Buffer с использованием .buffer TypedArray можно использовать только часть базового ArrayBuffer, передав параметры byteOffset и length.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.length)
// Выводит: 16

CJS

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

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

console.log(buf.length)
// Выводит: 16

Buffer.from() и TypedArray.from() имеют разные сигнатуры и реализации. В частности, варианты TypedArray принимают второй аргумент, который является функцией отображения, вызываемой для каждого элемента типизированного массива:

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

Однако метод Buffer.from() не поддерживает использование функции отображения:

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

Буферы и итерация

Экземпляры Buffer могут быть итерированы с помощью синтаксиса for..of:

ESM

import { Buffer } from 'node:buffer'

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

for (const b of buf) {
  console.log(b)
}
// Выводит:
//   1
//   2
//   3

CJS

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

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

for (const b of buf) {
  console.log(b)
}
// Выводит:
//   1
//   2
//   3

Кроме того, методы buf.values(), buf.keys() и buf.entries() могут быть использованы для создания итераторов.

Класс: Blob

[История]

Версия	Изменения
v18.0.0, v16.17.0	Больше не экспериментальный.
v15.7.0, v14.18.0	Добавлено в: v15.7.0, v14.18.0

Blob инкапсулирует неизменяемые необработанные данные, которыми можно безопасно делиться между несколькими рабочими потоками.

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

[История]

Версия	Изменения
v16.7.0	Добавлен стандартный параметр endings для замены концов строк и удален нестандартный параметр encoding.
v15.7.0, v14.18.0	Добавлено в: v15.7.0, v14.18.0

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> Массив строк, объектов <ArrayBuffer>, <TypedArray>, <DataView> или <Blob>, или любая смесь таких объектов, которые будут храниться внутри Blob.
• options <Object>
  • endings <string> Одно из значений: 'transparent' или 'native'. Если установлено значение 'native', концы строк в частях исходной строки будут преобразованы в собственный конец строки платформы, как указано в require('node:os').EOL.
  • type <string> Тип содержимого Blob. Предполагается, что type передает MIME-тип данных, однако проверка формата типа не выполняется.

Создает новый объект Blob, содержащий конкатенацию заданных источников.

Источники <ArrayBuffer>, <TypedArray>, <DataView> и <Buffer> копируются в 'Blob' и, следовательно, могут быть безопасно изменены после создания 'Blob'.

Строковые источники кодируются как последовательности байтов UTF-8 и копируются в Blob. Несовпадающие суррогатные пары в каждой части строки будут заменены символами замены Unicode U+FFFD.

blob.arrayBuffer()

Добавлено в: v15.7.0, v14.18.0

• Возвращает: <Promise>

Возвращает промис, который разрешается с <ArrayBuffer>, содержащим копию данных Blob.

blob.bytes()

Добавлено в: v22.3.0, v20.16.0

Метод blob.bytes() возвращает байты объекта Blob в виде Promise\<Uint8Array\>.

const blob = new Blob(['hello'])
blob.bytes().then(bytes => {
  console.log(bytes) // Выводит: Uint8Array(5) [ 104, 101, 108, 108, 111 ]
})

blob.size

Добавлено в: v15.7.0, v14.18.0

Общий размер Blob в байтах.

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

Добавлено в: v15.7.0, v14.18.0

• start <number> Начальный индекс.
• end <number> Конечный индекс.
• type <string> Тип контента для нового Blob

Создает и возвращает новый Blob, содержащий подмножество данных этого объекта Blob. Исходный Blob не изменяется.

blob.stream()

Добавлено в: v16.7.0

• Возвращает: <ReadableStream>

Возвращает новый ReadableStream, позволяющий читать содержимое Blob.

blob.text()

Добавлено в: v15.7.0, v14.18.0

• Возвращает: <Promise>

Возвращает промис, который разрешается содержимым Blob, декодированным как строка UTF-8.

blob.type

Добавлено в: v15.7.0, v14.18.0

• Тип: <string>

Тип контента Blob.

Объекты Blob и MessageChannel

После создания объекта <Blob>, его можно отправить через MessagePort нескольким получателям без передачи или немедленного копирования данных. Данные, содержащиеся в Blob, копируются только при вызове методов arrayBuffer() или 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)

// Blob по-прежнему можно использовать после отправки.
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)

// Blob по-прежнему можно использовать после отправки.
blob.text().then(console.log)

Класс: Buffer

Класс Buffer является глобальным типом для непосредственной работы с бинарными данными. Его можно создать различными способами.

Статический метод: Buffer.alloc(size[, fill[, encoding]])

[История]

Версия	Изменения
v20.0.0	Выбрасывается ERR_INVALID_ARG_TYPE или ERR_OUT_OF_RANGE вместо ERR_INVALID_ARG_VALUE для недопустимых входных аргументов.
v15.0.0	Выбрасывается ERR_INVALID_ARG_VALUE вместо ERR_INVALID_OPT_VALUE для недопустимых входных аргументов.
v10.0.0	Попытка заполнить буфер ненулевой длины буфером нулевой длины вызывает исключение.
v10.0.0	Указание недопустимой строки для fill вызывает исключение.
v8.9.3	Указание недопустимой строки для fill теперь приводит к заполнению буфера нулями.
v5.10.0	Добавлено в: v5.10.0

• size <integer> Желаемая длина нового Buffer в байтах.
• fill <string> | <Buffer> | <Uint8Array> | <integer> Значение для предварительного заполнения нового Buffer. По умолчанию: 0.
• encoding <string> Если fill является строкой, то это его кодировка. По умолчанию: 'utf8'.
• Возвращает: <Buffer>

Выделяет новый Buffer размером size байт. Если fill не определен, то Buffer будет заполнен нулями.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(5)

console.log(buf)
// Выводит: <Buffer 00 00 00 00 00>

CJS

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

const buf = Buffer.alloc(5)

console.log(buf)
// Выводит: <Buffer 00 00 00 00 00>

Если size больше, чем buffer.constants.MAX_LENGTH, или меньше 0, выбрасывается ERR_OUT_OF_RANGE.

Если указан fill, то выделенный Buffer будет инициализирован вызовом buf.fill(fill).

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf)
// Выводит: <Buffer 61 61 61 61 61>

CJS

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

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

console.log(buf)
// Выводит: <Buffer 61 61 61 61 61>

Если указаны fill и encoding, то выделенный Buffer будет инициализирован вызовом buf.fill(fill, encoding).

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>

Вызов Buffer.alloc() может быть заметно медленнее, чем альтернативный Buffer.allocUnsafe(), но он гарантирует, что содержимое нового созданного экземпляра Buffer никогда не будет содержать конфиденциальные данные из предыдущих выделений, включая данные, которые могли быть выделены не для Buffer.

Если size не является числом, будет вызван TypeError.

Статический метод: Buffer.allocUnsafe(size)

[История]

Версия	Изменения
v20.0.0	Выбрасывает ERR_INVALID_ARG_TYPE или ERR_OUT_OF_RANGE вместо ERR_INVALID_ARG_VALUE для недопустимых входных аргументов.
v15.0.0	Выбрасывает ERR_INVALID_ARG_VALUE вместо ERR_INVALID_OPT_VALUE для недопустимых входных аргументов.
v7.0.0	Передача отрицательного значения size теперь приведет к ошибке.
v5.10.0	Добавлено в: v5.10.0

• size <integer> Желаемая длина нового Buffer.
• Возвращает: <Buffer>

Выделяет новый Buffer размером size байт. Если size больше, чем buffer.constants.MAX_LENGTH или меньше 0, выбрасывается ERR_OUT_OF_RANGE.

Базовая память для экземпляров Buffer, созданных таким образом, не инициализируется. Содержимое вновь созданного Buffer неизвестно и может содержать конфиденциальные данные. Вместо этого используйте Buffer.alloc() для инициализации экземпляров Buffer нулями.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(10)

console.log(buf)
// Выводит (содержимое может варьироваться): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0)

console.log(buf)
// Выводит: <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)
// Выводит (содержимое может варьироваться): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0)

console.log(buf)
// Выводит: <Buffer 00 00 00 00 00 00 00 00 00 00>

Если size не является числом, будет выброшено исключение TypeError.

Модуль Buffer предварительно выделяет внутренний экземпляр Buffer размером Buffer.poolSize, который используется в качестве пула для быстрого выделения новых экземпляров Buffer, создаваемых с помощью Buffer.allocUnsafe(), Buffer.from(array), Buffer.from(string) и Buffer.concat() только тогда, когда size меньше Buffer.poolSize >>> 1 (целая часть от Buffer.poolSize деленная на два).

Использование этого предварительно выделенного внутреннего пула памяти является ключевым отличием между вызовом Buffer.alloc(size, fill) и Buffer.allocUnsafe(size).fill(fill). В частности, Buffer.alloc(size, fill) никогда не будет использовать внутренний пул Buffer, тогда как Buffer.allocUnsafe(size).fill(fill) будет использовать внутренний пул Buffer, если size меньше или равно половине Buffer.poolSize. Разница незначительна, но может быть важна, когда приложению требуется дополнительная производительность, которую обеспечивает Buffer.allocUnsafe().

Статический метод: Buffer.allocUnsafeSlow(size)

[История]

Версия	Изменения
v20.0.0	Выбрасывает ERR_INVALID_ARG_TYPE или ERR_OUT_OF_RANGE вместо ERR_INVALID_ARG_VALUE для недопустимых входных аргументов.
v15.0.0	Выбрасывает ERR_INVALID_ARG_VALUE вместо ERR_INVALID_OPT_VALUE для недопустимых входных аргументов.
v5.12.0	Добавлено в: v5.12.0

• size <integer> Желаемая длина нового Buffer.
• Возвращает: <Buffer>

Выделяет новый Buffer размером size байтов. Если size больше, чем buffer.constants.MAX_LENGTH или меньше 0, то выбрасывается ERR_OUT_OF_RANGE. Buffer нулевой длины создается, если size равно 0.

Базовая память для экземпляров Buffer, созданных таким образом, не инициализируется. Содержимое вновь созданного Buffer неизвестно и может содержать конфиденциальные данные. Используйте buf.fill(0) для инициализации таких экземпляров Buffer нулями.

При использовании Buffer.allocUnsafe() для выделения новых экземпляров Buffer, выделения меньше, чем Buffer.poolSize \>\>\> 1 (4 КиБ при использовании размера пула по умолчанию), извлекаются из одного предварительно выделенного Buffer. Это позволяет приложениям избежать накладных расходов сборки мусора при создании множества индивидуально выделенных экземпляров Buffer. Этот подход улучшает как производительность, так и использование памяти, устраняя необходимость отслеживать и очищать множество отдельных объектов ArrayBuffer.

Однако в случае, когда разработчику может потребоваться сохранить небольшой кусок памяти из пула в течение неопределенного периода времени, может быть целесообразно создать непулированный экземпляр Buffer с помощью Buffer.allocUnsafeSlow(), а затем скопировать соответствующие биты.

ESM

import { Buffer } from 'node:buffer'

// Нужно сохранить несколько небольших кусков памяти.
const store = []

socket.on('readable', () => {
  let data
  while (null !== (data = readable.read())) {
    // Выделить память для сохраняемых данных.
    const sb = Buffer.allocUnsafeSlow(10)

    // Скопировать данные в новое выделение.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

CJS

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

// Нужно сохранить несколько небольших кусков памяти.
const store = []

socket.on('readable', () => {
  let data
  while (null !== (data = readable.read())) {
    // Выделить память для сохраняемых данных.
    const sb = Buffer.allocUnsafeSlow(10)

    // Скопировать данные в новое выделение.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

Если size не является числом, будет выброшен TypeError.

Статический метод: Buffer.byteLength(string[, encoding])

[История]

Версия	Изменения
v7.0.0	Передача неверных входных данных теперь вызывает ошибку.
v5.10.0	Параметр string теперь может быть любым TypedArray, DataView или ArrayBuffer.
v0.1.90	Добавлено в: v0.1.90

• string <string> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> Значение, для которого нужно вычислить длину.
• encoding <string> Если string - строка, это ее кодировка. По умолчанию: 'utf8'.
• Возвращает: <integer> Количество байтов, содержащихся в string.

Возвращает длину строки в байтах при кодировании с использованием encoding. Это не то же самое, что String.prototype.length, который не учитывает кодировку, используемую для преобразования строки в байты.

Для 'base64', 'base64url' и 'hex' эта функция предполагает действительный ввод. Для строк, содержащих данные, не закодированные в base64/hex (например, пробелы), возвращаемое значение может быть больше длины Buffer, созданного из строки.

ESM

import { Buffer } from 'node:buffer'

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

console.log(`${str}: ${str.length} characters, ` + `${Buffer.byteLength(str, 'utf8')} bytes`)
// Выводит: ½ + ¼ = ¾: 9 characters, 12 bytes

CJS

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

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

console.log(`${str}: ${str.length} characters, ` + `${Buffer.byteLength(str, 'utf8')} bytes`)
// Выводит: ½ + ¼ = ¾: 9 characters, 12 bytes

Когда string является Buffer/DataView/TypedArray/ArrayBuffer/ SharedArrayBuffer, возвращается длина байта, указанная в .byteLength.

Статический метод: Buffer.compare(buf1, buf2)

[История]

Версия	Изменения
v8.0.0	Аргументы теперь могут быть Uint8Array.
v0.11.13	Добавлено в: v0.11.13

• buf1 <Buffer> | <Uint8Array>
• buf2 <Buffer> | <Uint8Array>
• Возвращает: <integer> Либо -1, 0, или 1, в зависимости от результата сравнения. Подробности см. в buf.compare().

Сравнивает buf1 с buf2, обычно для целей сортировки массивов экземпляров Buffer. Это эквивалентно вызову 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))
// Выводит: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (Этот результат равен: [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))
// Выводит: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (Этот результат равен: [buf2, buf1].)

Статический метод: Buffer.concat(list[, totalLength])

[История]

Версия	Изменения
v8.0.0	Элементы list теперь могут быть Uint8Array.
v0.7.11	Добавлено в: v0.7.11

• list <Buffer[]> | <Uint8Array[]> Список экземпляров Buffer или Uint8Array для объединения.
• totalLength <integer> Общая длина экземпляров Buffer в list при объединении.
• Возвращает: <Buffer>

Возвращает новый Buffer, который является результатом объединения всех экземпляров Buffer в list.

Если список не содержит элементов или если totalLength равно 0, то возвращается новый Buffer нулевой длины.

Если totalLength не указан, он вычисляется из экземпляров Buffer в list путем сложения их длин.

Если totalLength указан, он приводится к беззнаковому целому числу. Если общая длина Buffer в list превышает totalLength, результат усекается до totalLength. Если общая длина Buffer в list меньше totalLength, оставшееся пространство заполняется нулями.

ESM

import { Buffer } from 'node:buffer'

// Создаем один `Buffer` из списка трех экземпляров `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)
// Выводит: 42

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

console.log(bufA)
// Выводит: <Buffer 00 00 00 00 ...>
console.log(bufA.length)
// Выводит: 42

CJS

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

// Создаем один `Buffer` из списка трех экземпляров `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)
// Выводит: 42

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

console.log(bufA)
// Выводит: <Buffer 00 00 00 00 ...>
console.log(bufA.length)
// Выводит: 42

Buffer.concat() также может использовать внутренний пул Buffer, как и Buffer.allocUnsafe().

Статический метод: Buffer.copyBytesFrom(view[, offset[, length]])

Добавлено в: v19.8.0, v18.16.0

• view <TypedArray> <TypedArray> для копирования.
• offset <integer> Начальное смещение внутри view. По умолчанию: 0.
• length <integer> Количество элементов из view для копирования. По умолчанию: view.length - offset.
• Возвращает: <Buffer>

Копирует основную память view в новый 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

Статический метод: Buffer.from(array)

Добавлено в: v5.10.0

• array <integer[]>
• Возвращает: <Buffer>

Выделяет новый Buffer, используя array байтов в диапазоне 0–255. Записи массива за пределами этого диапазона будут усечены, чтобы поместиться в него.

ESM

import { Buffer } from 'node:buffer'

// Создает новый Buffer, содержащий UTF-8 байты строки 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

CJS

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

// Создает новый Buffer, содержащий UTF-8 байты строки 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

Если array является объектом, подобным Array (то есть, с свойством length типа number), он рассматривается как массив, если это не Buffer или Uint8Array. Это означает, что все другие варианты TypedArray рассматриваются как Array. Чтобы создать Buffer из байтов, поддерживающих TypedArray, используйте Buffer.copyBytesFrom().

TypeError будет выброшен, если array не является Array или другим типом, подходящим для вариантов Buffer.from().

Buffer.from(array) и Buffer.from(string) также могут использовать внутренний пул Buffer, как это делает Buffer.allocUnsafe().

Статический метод: Buffer.from(arrayBuffer[, byteOffset[, length]])

Добавлено в: v5.10.0

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> ArrayBuffer, SharedArrayBuffer, например, свойство .buffer TypedArray.
• byteOffset <integer> Индекс первого байта для отображения. По умолчанию: 0.
• length <integer> Количество отображаемых байтов. По умолчанию: arrayBuffer.byteLength - byteOffset.
• Возвращает: <Buffer>

Это создает представление ArrayBuffer без копирования лежащей в основе памяти. Например, при передаче ссылки на свойство .buffer экземпляра TypedArray, вновь созданный Buffer будет использовать ту же выделенную память, что и базовый ArrayBuffer TypedArray.

ESM

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

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

// Разделяет память с `arr`.
const buf = Buffer.from(arr.buffer)

console.log(buf)
// Выводит: <Buffer 88 13 a0 0f>

// Изменение исходного Uint16Array также изменяет Buffer.
arr[1] = 6000

console.log(buf)
// Выводит: <Buffer 88 13 70 17>

CJS

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

const arr = new Uint16Array(2)

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

// Разделяет память с `arr`.
const buf = Buffer.from(arr.buffer)

console.log(buf)
// Выводит: <Buffer 88 13 a0 0f>

// Изменение исходного Uint16Array также изменяет Buffer.
arr[1] = 6000

console.log(buf)
// Выводит: <Buffer 88 13 70 17>

Необязательные аргументы byteOffset и length определяют диапазон памяти внутри arrayBuffer, который будет совместно использоваться Buffer.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.length)
// Выводит: 2

CJS

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

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

console.log(buf.length)
// Выводит: 2

Ошибка TypeError будет сгенерирована, если arrayBuffer не является ArrayBuffer или SharedArrayBuffer или другим типом, подходящим для вариантов Buffer.from().

Важно помнить, что резервный ArrayBuffer может охватывать диапазон памяти, который выходит за границы представления TypedArray. Новый Buffer, созданный с использованием свойства buffer TypedArray, может выходить за диапазон TypedArray:

ESM

import { Buffer } from 'node:buffer'

const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]) // 4 элемента
const arrB = new Uint8Array(arrA.buffer, 1, 2) // 2 элемента
console.log(arrA.buffer === arrB.buffer) // true

const buf = Buffer.from(arrB.buffer)
console.log(buf)
// Выводит: <Buffer 63 64 65 66>

CJS

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

const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]) // 4 элемента
const arrB = new Uint8Array(arrA.buffer, 1, 2) // 2 элемента
console.log(arrA.buffer === arrB.buffer) // true

const buf = Buffer.from(arrB.buffer)
console.log(buf)
// Выводит: <Buffer 63 64 65 66>

Статический метод: Buffer.from(buffer)

Добавлено в: v5.10.0

• buffer <Buffer> | <Uint8Array> Существующий Buffer или Uint8Array, из которого копируются данные.
• Возвращает: <Buffer>

Копирует переданные данные buffer в новый экземпляр Buffer.

ESM

import { Buffer } from 'node:buffer'

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

buf1[0] = 0x61

console.log(buf1.toString())
// Выводит: auffer
console.log(buf2.toString())
// Выводит: buffer

CJS

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

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

buf1[0] = 0x61

console.log(buf1.toString())
// Выводит: auffer
console.log(buf2.toString())
// Выводит: buffer

TypeError будет вызван, если buffer не является Buffer или другим типом, подходящим для вариантов Buffer.from().

Статический метод: Buffer.from(object[, offsetOrEncoding[, length]])

Добавлено в: v8.2.0

• object <Object> Объект, поддерживающий Symbol.toPrimitive или valueOf().
• offsetOrEncoding <integer> | <string> Смещение байта или кодировка.
• length <integer> Длина.
• Возвращает: <Buffer>

Для объектов, чья функция valueOf() возвращает значение, не строго равное object, возвращает Buffer.from(object.valueOf(), offsetOrEncoding, length).

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from(new String('this is a test'))
// Выводит: <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'))
// Выводит: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>

Для объектов, поддерживающих Symbol.toPrimitive, возвращает 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')
// Выводит: <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')
// Выводит: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>

TypeError будет вызван, если у object нет упомянутых методов или он не относится к другому типу, подходящему для вариантов Buffer.from().

Статический метод: Buffer.from(string[, encoding])

Добавлено в: v5.10.0

• string <string> Строка для кодирования.
• encoding <string> Кодировка string. По умолчанию: 'utf8'.
• Возвращает: <Buffer>

Создает новый Buffer, содержащий string. Параметр encoding определяет кодировку символов, используемую при преобразовании string в байты.

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())
// Выводит: this is a tést
console.log(buf2.toString())
// Выводит: this is a tést
console.log(buf1.toString('latin1'))
// Выводит: 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())
// Выводит: this is a tést
console.log(buf2.toString())
// Выводит: this is a tést
console.log(buf1.toString('latin1'))
// Выводит: this is a tést

Будет выдана ошибка TypeError, если string не является строкой или другим типом, подходящим для вариантов Buffer.from().

Buffer.from(string) может также использовать внутренний пул Buffer, как и Buffer.allocUnsafe().

Статический метод: Buffer.isBuffer(obj)

Добавлено в: v0.1.101

• obj <Object>
• Возвращает: <boolean>

Возвращает true, если obj является Buffer, в противном случае false.

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

Статический метод: Buffer.isEncoding(encoding)

Добавлено в: v0.9.1

• encoding <string> Имя кодировки символов для проверки.
• Возвращает: <boolean>

Возвращает true, если encoding является именем поддерживаемой кодировки символов, или false в противном случае.

ESM

import { Buffer } from 'node:buffer'

console.log(Buffer.isEncoding('utf8'))
// Выводит: true

console.log(Buffer.isEncoding('hex'))
// Выводит: true

console.log(Buffer.isEncoding('utf/8'))
// Выводит: false

console.log(Buffer.isEncoding(''))
// Выводит: false

CJS

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

console.log(Buffer.isEncoding('utf8'))
// Выводит: true

console.log(Buffer.isEncoding('hex'))
// Выводит: true

console.log(Buffer.isEncoding('utf/8'))
// Выводит: false

console.log(Buffer.isEncoding(''))
// Выводит: false

Свойство класса: Buffer.poolSize

Добавлено в: v0.11.3

• <integer> По умолчанию: 8192

Это размер (в байтах) предварительно выделенных внутренних экземпляров Buffer, используемых для пула. Это значение можно изменить.

buf[index]

• index <integer>

Оператор индекса [index] можно использовать для получения и установки октета в позиции index в buf. Значения относятся к отдельным байтам, поэтому допустимый диапазон значений составляет от 0x00 до 0xFF (шестнадцатеричное значение) или от 0 до 255 (десятичное значение).

Этот оператор наследуется от Uint8Array, поэтому его поведение при выходе за границы такое же, как у Uint8Array. Другими словами, buf[index] возвращает undefined, когда index является отрицательным или больше или равен buf.length, а buf[index] = value не изменяет буфер, если index отрицательный или \>= buf.length.

ESM

import { Buffer } from 'node:buffer'

// Копируем строку ASCII в `Buffer` по одному байту за раз.
// (Это работает только для строк, состоящих только из ASCII. В общем, следует использовать
// `Buffer.from()` для выполнения этого преобразования.)

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'))
// Выводит: Node.js

CJS

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

// Копируем строку ASCII в `Buffer` по одному байту за раз.
// (Это работает только для строк, состоящих только из ASCII. В общем, следует использовать
// `Buffer.from()` для выполнения этого преобразования.)

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'))
// Выводит: Node.js

buf.buffer

• <ArrayBuffer> Базовый объект ArrayBuffer, на основе которого был создан данный объект Buffer.

Не гарантируется, что этот ArrayBuffer точно соответствует исходному Buffer. Подробнее см. примечания к buf.byteOffset.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buffer.buffer === arrayBuffer)
// Выводит: true

CJS

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

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

console.log(buffer.buffer === arrayBuffer)
// Выводит: true

buf.byteOffset

• <integer> Смещение byteOffset базового объекта ArrayBuffer для Buffer.

При установке byteOffset в Buffer.from(ArrayBuffer, byteOffset, length) или иногда при выделении Buffer размером меньше, чем Buffer.poolSize, буфер не начинается с нулевого смещения в базовом ArrayBuffer.

Это может вызвать проблемы при прямом доступе к базовому ArrayBuffer с помощью buf.buffer, так как другие части ArrayBuffer могут не иметь отношения к самому объекту Buffer.

Распространенная проблема при создании объекта TypedArray, который разделяет свою память с Buffer, заключается в том, что в этом случае необходимо правильно указать byteOffset:

ESM

import { Buffer } from 'node:buffer'

// Создаем буфер размером меньше, чем `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// При преобразовании Node.js Buffer в Int8Array используйте byteOffset
// чтобы обращаться только к той части `nodeBuffer.buffer`, которая содержит память
// для `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

CJS

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

// Создаем буфер размером меньше, чем `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// При преобразовании Node.js Buffer в Int8Array используйте byteOffset
// чтобы обращаться только к той части `nodeBuffer.buffer`, которая содержит память
// для `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

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

[История]

Версия	Изменения
v8.0.0	Параметр target теперь может быть Uint8Array.
v5.11.0	Теперь поддерживаются дополнительные параметры для указания смещений.
v0.11.13	Добавлено в: v0.11.13

• target <Buffer> | <Uint8Array> Buffer или Uint8Array с которым сравнивается buf.
• targetStart <integer> Смещение внутри target, с которого начинается сравнение. По умолчанию: 0.
• targetEnd <integer> Смещение внутри target, в котором заканчивается сравнение (не включительно). По умолчанию: target.length.
• sourceStart <integer> Смещение внутри buf, с которого начинается сравнение. По умолчанию: 0.
• sourceEnd <integer> Смещение внутри buf, в котором заканчивается сравнение (не включительно). По умолчанию: buf.length.
• Возвращает: <integer>

Сравнивает buf с target и возвращает число, указывающее, идет ли buf перед, после или совпадает с target в порядке сортировки. Сравнение основано на фактической последовательности байтов в каждом Buffer.

• 0 возвращается, если target совпадает с buf.
• 1 возвращается, если target должен идти перед buf при сортировке.
• -1 возвращается, если target должен идти после buf при сортировке.

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))
// Выводит: 0
console.log(buf1.compare(buf2))
// Выводит: -1
console.log(buf1.compare(buf3))
// Выводит: -1
console.log(buf2.compare(buf1))
// Выводит: 1
console.log(buf2.compare(buf3))
// Выводит: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Выводит: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (Этот результат равен: [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))
// Выводит: 0
console.log(buf1.compare(buf2))
// Выводит: -1
console.log(buf1.compare(buf3))
// Выводит: -1
console.log(buf2.compare(buf1))
// Выводит: 1
console.log(buf2.compare(buf3))
// Выводит: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Выводит: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (Этот результат равен: [buf1, buf3, buf2].)

Необязательные аргументы targetStart, targetEnd, sourceStart и sourceEnd могут использоваться для ограничения сравнения определенными диапазонами внутри target и buf соответственно.

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))
// Выводит: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Выводит: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Выводит: 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))
// Выводит: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Выводит: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Выводит: 1

ERR_OUT_OF_RANGE возникает, если targetStart < 0, sourceStart < 0, targetEnd > target.byteLength или sourceEnd > source.byteLength.

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

Добавлено в: v0.1.90

• target <Buffer> | <Uint8Array> Buffer или Uint8Array, в который нужно скопировать.
• targetStart <integer> Смещение внутри target, с которого начинается запись. По умолчанию: 0.
• sourceStart <integer> Смещение внутри buf, с которого начинается копирование. По умолчанию: 0.
• sourceEnd <integer> Смещение внутри buf, на котором заканчивается копирование (не включительно). По умолчанию: buf.length.
• Возвращает: <integer> Количество скопированных байтов.

Копирует данные из области buf в область в target, даже если область памяти target перекрывается с buf.

TypedArray.prototype.set() выполняет ту же операцию и доступен для всех TypedArray, включая Node.js Buffers, хотя принимает другие аргументы функции.

ESM

import { Buffer } from 'node:buffer'

// Создаем два экземпляра `Buffer`.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

for (let i = 0; i < 26; i++) {
  // 97 это десятичное ASCII-значение для 'a'.
  buf1[i] = i + 97
}

// Копируем байты `buf1` с 16 по 19 в `buf2`, начиная с 8 байта `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Это эквивалентно:
// buf2.set(buf1.subarray(16, 20), 8);

console.log(buf2.toString('ascii', 0, 25))
// Выводит: !!!!!!!!qrst!!!!!!!!!!!!!

CJS

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

// Создаем два экземпляра `Buffer`.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

for (let i = 0; i < 26; i++) {
  // 97 это десятичное ASCII-значение для 'a'.
  buf1[i] = i + 97
}

// Копируем байты `buf1` с 16 по 19 в `buf2`, начиная с 8 байта `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Это эквивалентно:
// buf2.set(buf1.subarray(16, 20), 8);

console.log(buf2.toString('ascii', 0, 25))
// Выводит: !!!!!!!!qrst!!!!!!!!!!!!!

ESM

import { Buffer } from 'node:buffer'

// Создаем `Buffer` и копируем данные из одной области в перекрывающуюся область
// внутри того же `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 это десятичное ASCII-значение для 'a'.
  buf[i] = i + 97
}

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

console.log(buf.toString())
// Выводит: efghijghijklmnopqrstuvwxyz

CJS

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

// Создаем `Buffer` и копируем данные из одной области в перекрывающуюся область
// внутри того же `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 это десятичное ASCII-значение для 'a'.
  buf[i] = i + 97
}

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

console.log(buf.toString())
// Выводит: efghijghijklmnopqrstuvwxyz

buf.entries()

Добавлено в версии: v1.1.0

• Возвращает: <Iterator>

Создает и возвращает итератор пар [индекс, байт] из содержимого buf.

ESM

import { Buffer } from 'node:buffer'

// Вывести все содержимое `Buffer`.

const buf = Buffer.from('buffer')

for (const pair of buf.entries()) {
  console.log(pair)
}
// Выводит:
//   [0, 98]
//   [1, 117]
//   [2, 102]
//   [3, 102]
//   [4, 101]
//   [5, 114]

CJS

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

// Вывести все содержимое `Buffer`.

const buf = Buffer.from('buffer')

for (const pair of buf.entries()) {
  console.log(pair)
}
// Выводит:
//   [0, 98]
//   [1, 117]
//   [2, 102]
//   [3, 102]
//   [4, 101]
//   [5, 114]

buf.equals(otherBuffer)

[История]

Версия	Изменения
v8.0.0	Аргументы теперь могут быть Uint8Array.
v0.11.13	Добавлено в версии: v0.11.13

• otherBuffer <Buffer> | <Uint8Array> Buffer или Uint8Array, с которым нужно сравнить buf.
• Возвращает: <boolean>

Возвращает true, если buf и otherBuffer имеют точно такие же байты, иначе возвращает false. Эквивалентно 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))
// Выводит: true
console.log(buf1.equals(buf3))
// Выводит: 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))
// Выводит: true
console.log(buf1.equals(buf3))
// Выводит: false

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

[История]

Версия	Изменения
v11.0.0	Выбрасывает ERR_OUT_OF_RANGE вместо ERR_INDEX_OUT_OF_RANGE.
v10.0.0	Отрицательные значения end вызывают ошибку ERR_INDEX_OUT_OF_RANGE.
v10.0.0	Попытка заполнить буфер ненулевой длины буфером нулевой длины вызывает выброс исключения.
v10.0.0	Указание недействительной строки для value вызывает выброс исключения.
v5.7.0	Теперь поддерживается параметр encoding.
v0.5.0	Добавлено в: v0.5.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Значение, которым нужно заполнить buf. Пустое значение (строка, Uint8Array, Buffer) приводится к 0.
• offset <integer> Количество байтов, которое нужно пропустить перед началом заполнения buf. По умолчанию: 0.
• end <integer> Место, где нужно остановить заполнение buf (не включительно). По умолчанию: buf.length.
• encoding <string> Кодировка для value, если value является строкой. По умолчанию: 'utf8'.
• Возвращает: <Buffer> Ссылку на buf.

Заполняет buf указанным value. Если offset и end не указаны, будет заполнен весь buf:

ESM

import { Buffer } from 'node:buffer'

// Заполнить `Buffer` ASCII-символом 'h'.

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

console.log(b.toString())
// Выводит: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Заполнить буфер пустой строкой
const c = Buffer.allocUnsafe(5).fill('')

console.log(c.fill(''))
// Выводит: <Buffer 00 00 00 00 00>

CJS

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

// Заполнить `Buffer` ASCII-символом 'h'.

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

console.log(b.toString())
// Выводит: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Заполнить буфер пустой строкой
const c = Buffer.allocUnsafe(5).fill('')

console.log(c.fill(''))
// Выводит: <Buffer 00 00 00 00 00>

value приводится к значению uint32, если это не строка, Buffer или целое число. Если полученное целое число больше 255 (десятичное), buf будет заполнен value & 255.

Если последняя запись операции fill() попадает на многобайтовый символ, то записываются только те байты этого символа, которые помещаются в buf:

ESM

import { Buffer } from 'node:buffer'

// Заполнить `Buffer` символом, который занимает два байта в UTF-8.

console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// Выводит: <Buffer c8 a2 c8 a2 c8>

CJS

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

// Заполнить `Buffer` символом, который занимает два байта в UTF-8.

console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// Выводит: <Buffer c8 a2 c8 a2 c8>

Если value содержит недопустимые символы, оно усекается; если не остается допустимых данных для заполнения, возникает исключение:

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(5)

console.log(buf.fill('a'))
// Выводит: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Выводит: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// Выбрасывает исключение.

CJS

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

const buf = Buffer.allocUnsafe(5)

console.log(buf.fill('a'))
// Выводит: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Выводит: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// Выбрасывает исключение.

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

Добавлено в: v5.3.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Что искать.
• byteOffset <integer> Где начать поиск в buf. Если отрицательное, то смещение вычисляется от конца buf. По умолчанию: 0.
• encoding <string> Если value является строкой, это её кодировка. По умолчанию: 'utf8'.
• Возвращает: <boolean> true, если value было найдено в buf, false в противном случае.

Эквивалентно buf.indexOf() !== -1.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.includes('this'))
// Выводит: true
console.log(buf.includes('is'))
// Выводит: true
console.log(buf.includes(Buffer.from('a buffer')))
// Выводит: true
console.log(buf.includes(97))
// Выводит: true (97 - это десятичное ASCII значение для 'a')
console.log(buf.includes(Buffer.from('a buffer example')))
// Выводит: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Выводит: true
console.log(buf.includes('this', 4))
// Выводит: false

CJS

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

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

console.log(buf.includes('this'))
// Выводит: true
console.log(buf.includes('is'))
// Выводит: true
console.log(buf.includes(Buffer.from('a buffer')))
// Выводит: true
console.log(buf.includes(97))
// Выводит: true (97 - это десятичное ASCII значение для 'a')
console.log(buf.includes(Buffer.from('a buffer example')))
// Выводит: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Выводит: true
console.log(buf.includes('this', 4))
// Выводит: false

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

[История]

Версия	Изменения
v8.0.0	Теперь value может быть Uint8Array.
v5.7.0, v4.4.0	Когда передается encoding, параметр byteOffset больше не является обязательным.
v1.5.0	Добавлено в: v1.5.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Что искать.
• byteOffset <integer> Где начать поиск в buf. Если отрицательное, то смещение вычисляется от конца buf. По умолчанию: 0.
• encoding <string> Если value является строкой, это кодировка, используемая для определения двоичного представления строки, которая будет искаться в buf. По умолчанию: 'utf8'.
• Возвращает: <integer> Индекс первого вхождения value в buf, или -1, если buf не содержит value.

Если value является:

• строкой, value интерпретируется в соответствии с кодировкой символов в encoding.
• Buffer или Uint8Array, value будет использоваться целиком. Чтобы сравнить частичный Buffer, используйте buf.subarray.
• числом, value будет интерпретировано как 8-битное целое число без знака в диапазоне от 0 до 255.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.indexOf('this'))
// Выводит: 0
console.log(buf.indexOf('is'))
// Выводит: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Выводит: 8
console.log(buf.indexOf(97))
// Выводит: 8 (97 - десятичное значение ASCII для 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Выводит: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Выводит: 8

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

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// Выводит: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// Выводит: 6

CJS

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

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

console.log(buf.indexOf('this'))
// Выводит: 0
console.log(buf.indexOf('is'))
// Выводит: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Выводит: 8
console.log(buf.indexOf(97))
// Выводит: 8 (97 - десятичное значение ASCII для 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Выводит: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Выводит: 8

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

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// Выводит: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// Выводит: 6

Если value не является строкой, числом или Buffer, этот метод вызовет TypeError. Если value является числом, оно будет приведено к допустимому значению байта, целое число от 0 до 255.

Если byteOffset не является числом, оно будет приведено к числу. Если результатом приведения является NaN или 0, то будет выполнен поиск по всему буферу. Это поведение соответствует String.prototype.indexOf().

ESM

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Передача значения, которое является числом, но не является допустимым байтом.
// Выводит: 2, что эквивалентно поиску 99 или 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Передача byteOffset, который приводится к NaN или 0.
// Выводит: 1, поиск по всему буферу.
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')

// Передача значения, которое является числом, но не является допустимым байтом.
// Выводит: 2, что эквивалентно поиску 99 или 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Передача byteOffset, который приводится к NaN или 0.
// Выводит: 1, поиск по всему буферу.
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))

Если value является пустой строкой или пустым Buffer и byteOffset меньше buf.length, будет возвращено byteOffset. Если value является пустым и byteOffset по крайней мере buf.length, будет возвращено buf.length.

buf.keys()

Добавлено в: v1.1.0

• Возвращает: <Iterator>

Создает и возвращает итератор ключей (индексов) buf.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

for (const key of buf.keys()) {
  console.log(key)
}
// Выводит:
//   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)
}
// Выводит:
//   0
//   1
//   2
//   3
//   4
//   5

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

[История]

Версия	Изменения
v8.0.0	Теперь value может быть Uint8Array.
v6.0.0	Добавлено в: v6.0.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Что искать.
• byteOffset <integer> Где начать поиск в buf. Если отрицательное, то смещение вычисляется с конца buf. По умолчанию: buf.length - 1.
• encoding <string> Если value является строкой, это кодировка, используемая для определения двоичного представления строки, которая будет искаться в buf. По умолчанию: 'utf8'.
• Возвращает: <integer> Индекс последнего вхождения value в buf или -1, если buf не содержит value.

Идентичен buf.indexOf(), за исключением того, что находится последнее вхождение value, а не первое.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.lastIndexOf('this'))
// Выводит: 0
console.log(buf.lastIndexOf('buffer'))
// Выводит: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// Выводит: 17
console.log(buf.lastIndexOf(97))
// Выводит: 15 (97 - десятичное ASCII-значение для 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// Выводит: -1
console.log(buf.lastIndexOf('buffer', 5))
// Выводит: 5
console.log(buf.lastIndexOf('buffer', 4))
// Выводит: -1

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

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'))
// Выводит: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'))
// Выводит: 4

CJS

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

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

console.log(buf.lastIndexOf('this'))
// Выводит: 0
console.log(buf.lastIndexOf('buffer'))
// Выводит: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// Выводит: 17
console.log(buf.lastIndexOf(97))
// Выводит: 15 (97 - десятичное ASCII-значение для 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// Выводит: -1
console.log(buf.lastIndexOf('buffer', 5))
// Выводит: 5
console.log(buf.lastIndexOf('buffer', 4))
// Выводит: -1

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

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'))
// Выводит: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'))
// Выводит: 4

Если value не является строкой, числом или Buffer, этот метод выдаст TypeError. Если value является числом, оно будет приведено к допустимому значению байта, целого числа от 0 до 255.

Если byteOffset не является числом, он будет приведен к числу. Любые аргументы, которые приводятся к NaN, например, {} или undefined, будут искать по всему буферу. Это поведение соответствует String.prototype.lastIndexOf().

ESM

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Передача значения, которое является числом, но не является допустимым байтом.
// Выводит: 2, эквивалентно поиску 99 или 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Передача byteOffset, который приводится к NaN.
// Выводит: 1, поиск по всему буферу.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Передача byteOffset, который приводится к 0.
// Выводит: -1, эквивалентно передаче 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

CJS

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

const b = Buffer.from('abcdef')

// Передача значения, которое является числом, но не является допустимым байтом.
// Выводит: 2, эквивалентно поиску 99 или 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Передача byteOffset, который приводится к NaN.
// Выводит: 1, поиск по всему буферу.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Передача byteOffset, который приводится к 0.
// Выводит: -1, эквивалентно передаче 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

Если value является пустой строкой или пустым Buffer, будет возвращен byteOffset.

buf.length

Добавлено в версии: v0.1.90

• <целое число>

Возвращает количество байтов в buf.

ESM

import { Buffer } from 'node:buffer'

// Создайте `Buffer` и запишите в него более короткую строку, используя UTF-8.

const buf = Buffer.alloc(1234)

console.log(buf.length)
// Выводит: 1234

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

console.log(buf.length)
// Выводит: 1234

CJS

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

// Создайте `Buffer` и запишите в него более короткую строку, используя UTF-8.

const buf = Buffer.alloc(1234)

console.log(buf.length)
// Выводит: 1234

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

console.log(buf.length)
// Выводит: 1234

buf.parent

Устарело с версии: v8.0.0

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело: Используйте buf.buffer вместо этого.

Свойство buf.parent является устаревшим псевдонимом для buf.buffer.

buf.readBigInt64BE([offset])

Добавлено в версии: v12.0.0, v10.20.0

• offset <целое число> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять: 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <bigint>

Читает 64-битное целое число со знаком с порядком байтов от старшего к младшему из buf по указанному offset.

Целые числа, прочитанные из Buffer, интерпретируются как значения со знаком в дополнительном коде.

buf.readBigInt64LE([offset])

Добавлено в версии: v12.0.0, v10.20.0

• offset <целое число> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять: 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <bigint>

Читает 64-битное целое число со знаком с порядком байтов от младшего к старшему из buf по указанному offset.

Целые числа, прочитанные из Buffer, интерпретируются как значения со знаком в дополнительном коде.

buf.readBigUInt64BE([offset])

[История]

Версия	Изменения
v14.10.0, v12.19.0	Эта функция также доступна как buf.readBigUint64BE().
v12.0.0, v10.20.0	Добавлено в: v12.0.0, v10.20.0

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию: 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <bigint>

Читает беззнаковое 64-битное целое число с порядком байтов от старшего к младшему (big-endian) из buf по указанному offset.

Эта функция также доступна под псевдонимом readBigUint64BE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readBigUInt64BE(0))
// Выводит: 4294967295n

CJS

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

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

console.log(buf.readBigUInt64BE(0))
// Выводит: 4294967295n

buf.readBigUInt64LE([offset])

[История]

Версия	Изменения
v14.10.0, v12.19.0	Эта функция также доступна как buf.readBigUint64LE().
v12.0.0, v10.20.0	Добавлено в: v12.0.0, v10.20.0

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию: 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <bigint>

Читает беззнаковое 64-битное целое число с порядком байтов от младшего к старшему (little-endian) из buf по указанному offset.

Эта функция также доступна под псевдонимом readBigUint64LE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readBigUInt64LE(0))
// Выводит: 18446744069414584320n

CJS

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

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

console.log(buf.readBigUInt64LE(0))
// Выводит: 18446744069414584320n

buf.readDoubleBE([offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32.
v0.11.15	Добавлено в: v0.11.15

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <number>

Считывает 64-битное число с плавающей точкой двойной точности в формате big-endian из buf по указанному offset.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readDoubleBE(0))
// Выводит: 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))
// Выводит: 8.20788039913184e-304

buf.readDoubleLE([offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32.
v0.11.15	Добавлено в: v0.11.15

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <number>

Считывает 64-битное число с плавающей точкой двойной точности в формате little-endian из buf по указанному offset.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readDoubleLE(0))
// Выводит: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Выбрасывает 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))
// Выводит: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Выбрасывает ERR_OUT_OF_RANGE.

buf.readFloatBE([offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и больше нет неявного приведения смещения к uint32.
v0.11.15	Добавлено в: v0.11.15

• offset <integer> Количество байтов для пропуска перед началом чтения. Должно удовлетворять условию 0 \<= offset \<= buf.length - 4. По умолчанию: 0.
• Возвращает: <number>

Читает 32-битное число с плавающей точкой в формате big-endian из buf по указанному offset.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readFloatBE(0))
// Выводит: 2.387939260590663e-38

CJS

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

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

console.log(buf.readFloatBE(0))
// Выводит: 2.387939260590663e-38

buf.readFloatLE([offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и больше нет неявного приведения смещения к uint32.
v0.11.15	Добавлено в: v0.11.15

• offset <integer> Количество байтов для пропуска перед началом чтения. Должно удовлетворять условию 0 \<= offset \<= buf.length - 4. По умолчанию: 0.
• Возвращает: <number>

Читает 32-битное число с плавающей точкой в формате little-endian из buf по указанному offset.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readFloatLE(0))
// Выводит: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Выбрасывает ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readFloatLE(0))
// Выводит: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Выбрасывает ERR_OUT_OF_RANGE.

buf.readInt8([offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32 более не выполняется.
v0.5.0	Добавлено в: v0.5.0

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 \<= offset \<= buf.length - 1. По умолчанию: 0.
• Возвращает: <integer>

Считывает знаковое 8-битное целое число из buf по указанному offset.

Целые числа, считанные из Buffer, интерпретируются как значения со знаком в дополнительном коде.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt8(0))
// Выводит: -1
console.log(buf.readInt8(1))
// Выводит: 5
console.log(buf.readInt8(2))
// Выбрасывает ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readInt8(0))
// Выводит: -1
console.log(buf.readInt8(1))
// Выводит: 5
console.log(buf.readInt8(2))
// Выбрасывает ERR_OUT_OF_RANGE.

buf.readInt16BE([offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32 более не выполняется.
v0.5.5	Добавлено в: v0.5.5

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 \<= offset \<= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer>

Считывает знаковое 16-битное целое число с прямым порядком байтов из buf по указанному offset.

Целые числа, считанные из Buffer, интерпретируются как значения со знаком в дополнительном коде.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt16BE(0))
// Выводит: 5

CJS

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

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

console.log(buf.readInt16BE(0))
// Выводит: 5

buf.readInt16LE([offset])

[История]

Версия	Изменения
v10.0.0	Удалено noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer>

Считывает знаковое 16-битное целое число в формате little-endian из buf по указанному offset.

Целые числа, считываемые из Buffer, интерпретируются как знаковые значения в дополнительном коде.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt16LE(0))
// Выводит: 1280
console.log(buf.readInt16LE(1))
// Выбрасывает ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readInt16LE(0))
// Выводит: 1280
console.log(buf.readInt16LE(1))
// Выбрасывает ERR_OUT_OF_RANGE.

buf.readInt32BE([offset])

[История]

Версия	Изменения
v10.0.0	Удалено noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer>

Считывает знаковое 32-битное целое число в формате big-endian из buf по указанному offset.

Целые числа, считываемые из Buffer, интерпретируются как знаковые значения в дополнительном коде.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt32BE(0))
// Выводит: 5

CJS

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

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

console.log(buf.readInt32BE(0))
// Выводит: 5

buf.readInt32LE([offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 \<= offset \<= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer>

Считывает знаковое 32-битное целое число с прямым порядком байтов из buf по указанному offset.

Целые числа, считываемые из Buffer, интерпретируются как значения со знаком в дополнительном коде.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readInt32LE(0))
// Выводит: 83886080
console.log(buf.readInt32LE(1))
// Выбрасывает ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readInt32LE(0))
// Выводит: 83886080
console.log(buf.readInt32LE(1))
// Выбрасывает ERR_OUT_OF_RANGE.

buf.readIntBE(offset, byteLength)

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения и byteLength к uint32.
v0.11.15	Добавлено в: v0.11.15

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Количество байтов для чтения. Должно удовлетворять условию 0 \< byteLength \<= 6.
• Возвращает: <integer>

Считывает byteLength байтов из buf по указанному offset и интерпретирует результат как знаковое значение с прямым порядком байтов в дополнительном коде, поддерживающее точность до 48 бит.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readIntBE(0, 6).toString(16))
// Выводит: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// Выбрасывает ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Выбрасывает 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))
// Выводит: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// Выбрасывает ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Выбрасывает ERR_OUT_OF_RANGE.

buf.readIntLE(offset, byteLength)

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения и byteLength к uint32.
v0.11.15	Добавлено в: v0.11.15

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - byteLength.
• byteLength <integer> Количество байтов для чтения. Должно удовлетворять условию 0 < byteLength <= 6.
• Возвращает: <integer>

Считывает byteLength байтов из buf по указанному offset и интерпретирует результат как знаковое значение с порядком байтов от младшего к старшему (little-endian) в дополнительном коде, поддерживающее точность до 48 бит.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readIntLE(0, 6).toString(16))
// Выводит: -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))
// Выводит: -546f87a9cbee

buf.readUInt8([offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.readUint8().
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32.
v0.5.0	Добавлено в: v0.5.0

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 1. По умолчанию: 0.
• Возвращает: <integer>

Считывает 8-битное целое число без знака из buf по указанному offset.

Эта функция также доступна под псевдонимом readUint8.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt8(0))
// Выводит: 1
console.log(buf.readUInt8(1))
// Выводит: 254
console.log(buf.readUInt8(2))
// Выбрасывает ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readUInt8(0))
// Выводит: 1
console.log(buf.readUInt8(1))
// Выводит: 254
console.log(buf.readUInt8(2))
// Выбрасывает ERR_OUT_OF_RANGE.

buf.readUInt16BE([offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.readUint16BE().
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer>

Читает 16-битное целое число без знака в формате big-endian из buf по указанному offset.

Эта функция также доступна под псевдонимом readUint16BE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt16BE(0).toString(16))
// Выводит: 1234
console.log(buf.readUInt16BE(1).toString(16))
// Выводит: 3456

CJS

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

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

console.log(buf.readUInt16BE(0).toString(16))
// Выводит: 1234
console.log(buf.readUInt16BE(1).toString(16))
// Выводит: 3456

buf.readUInt16LE([offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.readUint16LE().
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer>

Читает 16-битное целое число без знака в формате little-endian из buf по указанному offset.

Эта функция также доступна под псевдонимом readUint16LE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt16LE(0).toString(16))
// Выводит: 3412
console.log(buf.readUInt16LE(1).toString(16))
// Выводит: 5634
console.log(buf.readUInt16LE(2).toString(16))
// Выбрасывает ошибку ERR_OUT_OF_RANGE.

CJS

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

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

console.log(buf.readUInt16LE(0).toString(16))
// Выводит: 3412
console.log(buf.readUInt16LE(1).toString(16))
// Выводит: 5634
console.log(buf.readUInt16LE(2).toString(16))
// Выбрасывает ошибку ERR_OUT_OF_RANGE.

buf.readUInt32BE([offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.readUint32BE().
v10.0.0	Удалено noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer>

Считывает беззнаковое 32-битное целое число с прямым порядком байтов из buf по указанному offset.

Эта функция также доступна под псевдонимом readUint32BE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt32BE(0).toString(16))
// Выводит: 12345678

CJS

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

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

console.log(buf.readUInt32BE(0).toString(16))
// Выводит: 12345678

buf.readUInt32LE([offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.readUint32LE().
v10.0.0	Удалено noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer>

Считывает беззнаковое 32-битное целое число с обратным порядком байтов из buf по указанному offset.

Эта функция также доступна под псевдонимом readUint32LE.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt32LE(0).toString(16))
// Выводит: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Выбрасывает 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))
// Выводит: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Выбрасывает ERR_OUT_OF_RANGE.

buf.readUIntBE(offset, byteLength)

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.readUintBE().
v10.0.0	Удалены noAssert и неявное приведение смещения и byteLength к uint32.
v0.11.15	Добавлено в: v0.11.15

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Количество байтов для чтения. Должно удовлетворять условию 0 \< byteLength \<= 6.
• Возвращает: <integer>

Считывает byteLength байтов из buf с указанного offset и интерпретирует результат как беззнаковое целое число с прямым порядком байтов, поддерживающее точность до 48 бит.

Эта функция также доступна под псевдонимом 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))
// Выводит: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// Выбрасывает ошибку 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))
// Выводит: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// Выбрасывает ошибку ERR_OUT_OF_RANGE.

buf.readUIntLE(offset, byteLength)

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.readUintLE().
v10.0.0	Удалены noAssert и неявное приведение смещения и byteLength к uint32.
v0.11.15	Добавлено в: v0.11.15

• offset <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Количество байтов для чтения. Должно удовлетворять условию 0 \< byteLength \<= 6.
• Возвращает: <integer>

Считывает byteLength байтов из buf с указанного offset и интерпретирует результат как беззнаковое целое число с обратным порядком байтов, поддерживающее точность до 48 бит.

Эта функция также доступна под псевдонимом 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))
// Выводит: 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))
// Выводит: ab9078563412

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

Добавлено в: v3.0.0

• start <integer> Индекс, с которого начнётся новый Buffer. По умолчанию: 0.
• end <integer> Индекс, где закончится новый Buffer (не включительно). По умолчанию: buf.length.
• Возвращает: <Buffer>

Возвращает новый Buffer, который ссылается на ту же память, что и оригинал, но со смещением и обрезанный индексами start и end.

Указание end, большего чем buf.length, вернёт тот же результат, что и end, равный buf.length.

Этот метод унаследован от TypedArray.prototype.subarray().

Изменение нового среза Buffer изменит память в исходном Buffer, поскольку выделенная память двух объектов перекрывается.

ESM

import { Buffer } from 'node:buffer'

// Создадим `Buffer` с алфавитом ASCII, возьмем срез и изменим один байт
// из исходного `Buffer`.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 - это десятичное значение ASCII для 'a'.
  buf1[i] = i + 97
}

const buf2 = buf1.subarray(0, 3)

console.log(buf2.toString('ascii', 0, buf2.length))
// Выведет: abc

buf1[0] = 33

console.log(buf2.toString('ascii', 0, buf2.length))
// Выведет: !bc

CJS

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

// Создадим `Buffer` с алфавитом ASCII, возьмем срез и изменим один байт
// из исходного `Buffer`.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 - это десятичное значение ASCII для 'a'.
  buf1[i] = i + 97
}

const buf2 = buf1.subarray(0, 3)

console.log(buf2.toString('ascii', 0, buf2.length))
// Выведет: abc

buf1[0] = 33

console.log(buf2.toString('ascii', 0, buf2.length))
// Выведет: !bc

Указание отрицательных индексов приводит к тому, что срез генерируется относительно конца buf, а не начала.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

console.log(buf.subarray(-6, -1).toString())
// Выведет: buffe
// (Эквивалентно buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString())
// Выведет: buff
// (Эквивалентно buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString())
// Выведет: uff
// (Эквивалентно buf.subarray(1, 4).)

CJS

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

const buf = Buffer.from('buffer')

console.log(buf.subarray(-6, -1).toString())
// Выведет: buffe
// (Эквивалентно buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString())
// Выведет: buff
// (Эквивалентно buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString())
// Выведет: uff
// (Эквивалентно buf.subarray(1, 4).)

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

[История]

Версия	Изменения
v17.5.0, v16.15.0	Метод buf.slice() объявлен устаревшим.
v7.0.0	Все смещения теперь приводятся к целым числам до выполнения каких-либо вычислений с ними.
v7.1.0, v6.9.2	Приведение смещений к целым числам теперь корректно обрабатывает значения, выходящие за пределы 32-битного целочисленного диапазона.
v0.3.0	Добавлено в: v0.3.0

• start <integer> Где начнется новый Buffer. По умолчанию: 0.
• end <integer> Где закончится новый Buffer (не включительно). По умолчанию: buf.length.
• Возвращает: <Buffer>

[Стабильно: 0 - Устарело]

Стабильно: 0 Стабильность: 0 - Устарело: Используйте buf.subarray вместо этого.

Возвращает новый Buffer, который ссылается на ту же память, что и исходный, но со смещением и обрезкой по индексам start и end.

Этот метод несовместим с Uint8Array.prototype.slice(), который является суперклассом Buffer. Чтобы скопировать срез, используйте 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())
// Выводит: cuffer

console.log(buf.toString())
// Выводит: buffer

// При использовании buf.slice() исходный буфер изменяется.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Выводит: cuffer
console.log(buf.toString())
// Также выводит: 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())
// Выводит: cuffer

console.log(buf.toString())
// Выводит: buffer

// При использовании buf.slice() исходный буфер изменяется.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Выводит: cuffer
console.log(buf.toString())
// Также выводит: cuffer (!)

buf.swap16()

Добавлено в: v5.10.0

• Возвращает: <Buffer> Ссылка на buf.

Интерпретирует buf как массив 16-битных целых чисел без знака и меняет порядок байтов на месте. Выбрасывает ошибку ERR_INVALID_BUFFER_SIZE, если buf.length не кратна 2.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf1)
// Выводит: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap16()

console.log(buf1)
// Выводит: <Buffer 02 01 04 03 06 05 08 07>

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

buf2.swap16()
// Выбрасывает 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)
// Выводит: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap16()

console.log(buf1)
// Выводит: <Buffer 02 01 04 03 06 05 08 07>

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

buf2.swap16()
// Выбрасывает ERR_INVALID_BUFFER_SIZE.

Удобным вариантом использования buf.swap16() является быстрое преобразование на месте между UTF-16 little-endian и UTF-16 big-endian:

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // Преобразование в текст UTF-16 big-endian.

CJS

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

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // Преобразование в текст UTF-16 big-endian.

buf.swap32()

Добавлено в: v5.10.0

• Возвращает: <Buffer> Ссылка на buf.

Интерпретирует buf как массив 32-битных целых чисел без знака и меняет порядок байтов на месте. Выбрасывает ошибку ERR_INVALID_BUFFER_SIZE, если buf.length не кратна 4.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf1)
// Выводит: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap32()

console.log(buf1)
// Выводит: <Buffer 04 03 02 01 08 07 06 05>

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

buf2.swap32()
// Выбрасывает 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)
// Выводит: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap32()

console.log(buf1)
// Выводит: <Buffer 04 03 02 01 08 07 06 05>

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

buf2.swap32()
// Выбрасывает ERR_INVALID_BUFFER_SIZE.

buf.swap64()

Добавлено в: v6.3.0

• Возвращает: <Buffer> Ссылка на buf.

Интерпретирует buf как массив 64-битных чисел и меняет порядок байтов на месте. Выбрасывает ERR_INVALID_BUFFER_SIZE, если buf.length не кратно 8.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf1)
// Выводит: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap64()

console.log(buf1)
// Выводит: <Buffer 08 07 06 05 04 03 02 01>

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

buf2.swap64()
// Выбрасывает 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)
// Выводит: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap64()

console.log(buf1)
// Выводит: <Buffer 08 07 06 05 04 03 02 01>

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

buf2.swap64()
// Выбрасывает ERR_INVALID_BUFFER_SIZE.

buf.toJSON()

Добавлено в: v0.9.2

• Возвращает: <Object>

Возвращает JSON-представление buf. JSON.stringify() неявно вызывает эту функцию при преобразовании экземпляра Buffer в строку.

Buffer.from() принимает объекты в формате, возвращаемом этим методом. В частности, Buffer.from(buf.toJSON()) работает как 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)
// Выводит: {"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)
// Выводит: <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)
// Выводит: {"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)
// Выводит: <Buffer 01 02 03 04 05>

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

Добавлено в: v0.1.90

• encoding <string> Кодировка символов для использования. По умолчанию: 'utf8'.
• start <integer> Смещение байтов для начала декодирования. По умолчанию: 0.
• end <integer> Смещение байтов, где нужно остановить декодирование (не включительно). По умолчанию: buf.length.
• Возвращает: <string>

Декодирует buf в строку в соответствии с указанной кодировкой символов в encoding. start и end могут быть переданы для декодирования только подмножества buf.

Если encoding - 'utf8', и последовательность байтов во входных данных не является допустимой UTF-8, то каждый недопустимый байт заменяется символом замены U+FFFD.

Максимальная длина экземпляра строки (в кодовых единицах UTF-16) доступна как buffer.constants.MAX_STRING_LENGTH.

ESM

import { Buffer } from 'node:buffer'

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 - это десятичное ASCII-значение для 'a'.
  buf1[i] = i + 97
}

console.log(buf1.toString('utf8'))
// Выводит: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// Выводит: abcde

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

console.log(buf2.toString('hex'))
// Выводит: 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// Выводит: té
console.log(buf2.toString(undefined, 0, 3))
// Выводит: té

CJS

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

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 - это десятичное ASCII-значение для 'a'.
  buf1[i] = i + 97
}

console.log(buf1.toString('utf8'))
// Выводит: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// Выводит: abcde

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

console.log(buf2.toString('hex'))
// Выводит: 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// Выводит: té
console.log(buf2.toString(undefined, 0, 3))
// Выводит: té

buf.values()

Добавлено в: v1.1.0

• Возвращает: <Iterator>

Создаёт и возвращает итератор для значений (байтов) buf. Эта функция вызывается автоматически, когда Buffer используется в операторе for..of.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

for (const value of buf.values()) {
  console.log(value)
}
// Выводит:
//   98
//   117
//   102
//   102
//   101
//   114

for (const value of buf) {
  console.log(value)
}
// Выводит:
//   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)
}
// Выводит:
//   98
//   117
//   102
//   102
//   101
//   114

for (const value of buf) {
  console.log(value)
}
// Выводит:
//   98
//   117
//   102
//   102
//   101
//   114

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

Добавлено в: v0.1.90

• string <string> Строка для записи в buf.
• offset <integer> Количество байтов для пропуска перед началом записи string. По умолчанию: 0.
• length <integer> Максимальное количество байтов для записи (записанные байты не превысят buf.length - offset). По умолчанию: buf.length - offset.
• encoding <string> Кодировка символов string. По умолчанию: 'utf8'.
• Возвращает: <integer> Количество записанных байтов.

Записывает string в buf по адресу offset в соответствии с кодировкой символов в encoding. Параметр length — это количество байтов для записи. Если в buf недостаточно места для размещения всей строки, будет записана только часть string. Однако, частично закодированные символы не будут записаны.

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)}`)
// Выводит: 12 bytes: ½ + ¼ = ¾

const buffer = Buffer.alloc(10)

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

console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`)
// Выводит: 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)}`)
// Выводит: 12 bytes: ½ + ¼ = ¾

const buffer = Buffer.alloc(10)

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

console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`)
// Выводит: 2 bytes : ab

buf.writeBigInt64BE(value[, offset])

Добавлено в: v12.0.0, v10.20.0

• value <bigint> Число для записи в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию: 0 \<= offset \<= buf.length - 8. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset как big-endian.

value интерпретируется и записывается как знаковое целое число в дополнении до двух.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64BE(0x0102030405060708n, 0)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer 01 02 03 04 05 06 07 08>

buf.writeBigInt64LE(value[, offset])

Добавлено в: v12.0.0, v10.20.0

• value <bigint> Число для записи в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию: 0 \<= offset \<= buf.length - 8. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset как little-endian.

value интерпретируется и записывается как знаковое целое число в дополнении до двух.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64LE(0x0102030405060708n, 0)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer 08 07 06 05 04 03 02 01>

buf.writeBigUInt64BE(value[, offset])

[История]

Версия	Изменения
v14.10.0, v12.19.0	Эта функция также доступна как buf.writeBigUint64BE().
v12.0.0, v10.20.0	Добавлено в: v12.0.0, v10.20.0

• value <bigint> Число для записи в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять: 0 \<= offset \<= buf.length - 8. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset в формате big-endian.

Эта функция также доступна под псевдонимом writeBigUint64BE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64BE(0xdecafafecacefaden, 0)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer de ca fa fe ca ce fa de>

buf.writeBigUInt64LE(value[, offset])

[История]

Версия	Изменения
v14.10.0, v12.19.0	Эта функция также доступна как buf.writeBigUint64LE().
v12.0.0, v10.20.0	Добавлено в: v12.0.0, v10.20.0

• value <bigint> Число для записи в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять: 0 \<= offset \<= buf.length - 8. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset в формате little-endian.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64LE(0xdecafafecacefaden, 0)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer de fa ce ca fe fa ca de>

Эта функция также доступна под псевдонимом writeBigUint64LE.

buf.writeDoubleBE(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удален noAssert и больше нет неявного приведения смещения к uint32.
v0.11.15	Добавлено в: v0.11.15

• value <number> Число, которое нужно записать в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset в формате big-endian. value должно быть числом JavaScript. Поведение не определено, если value является чем-либо, кроме числа JavaScript.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleBE(123.456, 0)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer 40 5e dd 2f 1a 9f be 77>

buf.writeDoubleLE(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удален noAssert и больше нет неявного приведения смещения к uint32.
v0.11.15	Добавлено в: v0.11.15

• value <number> Число, которое нужно записать в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset в формате little-endian. value должно быть числом JavaScript. Поведение не определено, если value является чем-либо, кроме числа JavaScript.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleLE(123.456, 0)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer 77 be 9f 1a 2f dd 5e 40>

buf.writeFloatBE(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и больше нет неявного приведения смещения к uint32.
v0.11.15	Добавлено в: v0.11.15

• value <number> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которое нужно пропустить перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf с указанным offset в формате big-endian. Поведение не определено, если value не является числом JavaScript.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeFloatBE(0xcafebabe, 0)

console.log(buf)
// Выводит: <Buffer 4f 4a fe bb>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeFloatBE(0xcafebabe, 0)

console.log(buf)
// Выводит: <Buffer 4f 4a fe bb>

buf.writeFloatLE(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и больше нет неявного приведения смещения к uint32.
v0.11.15	Добавлено в: v0.11.15

• value <number> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которое нужно пропустить перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf с указанным offset в формате little-endian. Поведение не определено, если value не является числом JavaScript.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeFloatLE(0xcafebabe, 0)

console.log(buf)
// Выводит: <Buffer bb fe 4a 4f>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeFloatLE(0xcafebabe, 0)

console.log(buf)
// Выводит: <Buffer bb fe 4a 4f>

buf.writeInt8(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32.
v0.5.0	Добавлено в: v0.5.0

• value <integer> Число для записи в buf.
• offset <integer> Количество байтов для пропуска перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - 1. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset. value должно быть допустимым знаковым 8-битным целым числом. Поведение не определено, если value является чем-либо, кроме знакового 8-битного целого числа.

value интерпретируется и записывается как знаковое целое число в дополнении до двух.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

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

console.log(buf)
// Выведет: <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)
// Выведет: <Buffer 02 fe>

buf.writeInt16BE(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число для записи в buf.
• offset <integer> Количество байтов для пропуска перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset как big-endian. value должно быть допустимым знаковым 16-битным целым числом. Поведение не определено, если value является чем-либо, кроме знакового 16-битного целого числа.

value интерпретируется и записывается как знаковое целое число в дополнении до двух.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt16BE(0x0102, 0)

console.log(buf)
// Выведет: <Buffer 01 02>

CJS

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

const buf = Buffer.allocUnsafe(2)

buf.writeInt16BE(0x0102, 0)

console.log(buf)
// Выведет: <Buffer 01 02>

buf.writeInt16LE(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число, которое нужно записать в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset в формате little-endian. value должно быть допустимым знаковым 16-битным целым числом. Поведение не определено, если value является чем-либо иным, чем знаковое 16-битное целое число.

Значение value интерпретируется и записывается как знаковое целое число в дополнительном коде.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt16LE(0x0304, 0)

console.log(buf)
// Выводит: <Buffer 04 03>

CJS

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

const buf = Buffer.allocUnsafe(2)

buf.writeInt16LE(0x0304, 0)

console.log(buf)
// Выводит: <Buffer 04 03>

buf.writeInt32BE(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удалены noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число, которое нужно записать в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset в формате big-endian. value должно быть допустимым знаковым 32-битным целым числом. Поведение не определено, если value является чем-либо иным, чем знаковое 32-битное целое число.

Значение value интерпретируется и записывается как знаковое целое число в дополнительном коде.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeInt32BE(0x01020304, 0)

console.log(buf)
// Выводит: <Buffer 01 02 03 04>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeInt32BE(0x01020304, 0)

console.log(buf)
// Выводит: <Buffer 01 02 03 04>

buf.writeInt32LE(value[, offset])

[История]

Версия	Изменения
v10.0.0	Удалено noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число для записи в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset в формате little-endian. value должно быть допустимым 32-битным целым числом со знаком. Поведение не определено, если value является чем-либо иным, кроме 32-битного целого числа со знаком.

value интерпретируется и записывается как целое число со знаком в дополнительном коде.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeInt32LE(0x05060708, 0)

console.log(buf)
// Выводит: <Buffer 08 07 06 05>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeInt32LE(0x05060708, 0)

console.log(buf)
// Выводит: <Buffer 08 07 06 05>

buf.writeIntBE(value, offset, byteLength)

[История]

Версия	Изменения
v10.0.0	Удалено noAssert и больше нет неявного приведения смещения и byteLength к uint32.
v0.11.15	Добавлено в: v0.11.15

• value <integer> Число для записи в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Количество байтов для записи. Должно удовлетворять условию 0 < byteLength <= 6.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает byteLength байтов value в buf по указанному offset в формате big-endian. Поддерживает точность до 48 бит. Поведение не определено, если value является чем-либо иным, кроме целого числа со знаком.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeIntBE(0x1234567890ab, 0, 6)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer 12 34 56 78 90 ab>

buf.writeIntLE(value, offset, byteLength)

[История]

Версия	Изменения
v10.0.0	Убраны noAssert и неявное приведение смещения и byteLength к uint32.
v0.11.15	Добавлено в: v0.11.15

• value <integer> Число для записи в buf.
• offset <integer> Число байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Количество байтов для записи. Должно удовлетворять условию 0 < byteLength <= 6.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает byteLength байтов value в buf по указанному offset в формате little-endian. Поддерживает точность до 48 бит. Поведение не определено, если value не является целым числом со знаком.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeIntLE(0x1234567890ab, 0, 6)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer ab 90 78 56 34 12>

buf.writeUInt8(value[, offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.writeUint8().
v10.0.0	Убраны noAssert и неявное приведение смещения к uint32.
v0.5.0	Добавлено в: v0.5.0

• value <integer> Число для записи в buf.
• offset <integer> Число байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 1. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset. value должно быть допустимым 8-битным целым числом без знака. Поведение не определено, если value не является 8-битным целым числом без знака.

Эта функция также доступна под псевдонимом 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)
// Выводит: <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)
// Выводит: <Buffer 03 04 23 42>

buf.writeUInt16BE(value[, offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.writeUint16BE().
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32 больше не выполняется.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число для записи в buf.
• offset <integer> Количество байтов для пропуска перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset как big-endian. Значение value должно быть допустимым 16-битным целым числом без знака. Поведение не определено, если value является чем-либо, кроме 16-битного целого числа без знака.

Эта функция также доступна под псевдонимом writeUint16BE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer de ad be ef>

buf.writeUInt16LE(value[, offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.writeUint16LE().
v10.0.0	Удалены noAssert и неявное приведение смещения к uint32 больше не выполняется.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число для записи в buf.
• offset <integer> Количество байтов для пропуска перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf по указанному offset как little-endian. Значение value должно быть допустимым 16-битным целым числом без знака. Поведение не определено, если value является чем-либо, кроме 16-битного целого числа без знака.

Эта функция также доступна под псевдонимом writeUint16LE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16LE(0xdead, 0)
buf.writeUInt16LE(0xbeef, 2)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer ad de ef be>

buf.writeUInt32BE(value[, offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.writeUint32BE().
v10.0.0	Удалены noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число, которое нужно записать в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf с указанным offset как big-endian. value должен быть допустимым 32-битным целым числом без знака. Поведение не определено, если value не является 32-битным целым числом без знака.

Эта функция также доступна под псевдонимом writeUint32BE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32BE(0xfeedface, 0)

console.log(buf)
// Выводит: <Buffer fe ed fa ce>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32BE(0xfeedface, 0)

console.log(buf)
// Выводит: <Buffer fe ed fa ce>

buf.writeUInt32LE(value[, offset])

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.writeUint32LE().
v10.0.0	Удалены noAssert и больше нет неявного приведения смещения к uint32.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число, которое нужно записать в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает value в buf с указанным offset как little-endian. value должен быть допустимым 32-битным целым числом без знака. Поведение не определено, если value не является 32-битным целым числом без знака.

Эта функция также доступна под псевдонимом writeUint32LE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32LE(0xfeedface, 0)

console.log(buf)
// Выводит: <Buffer ce fa ed fe>

CJS

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

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32LE(0xfeedface, 0)

console.log(buf)
// Выводит: <Buffer ce fa ed fe>

buf.writeUIntBE(value, offset, byteLength)

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.writeUintBE().
v10.0.0	Удалены noAssert и неявное приведение смещения и byteLength к uint32.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число, которое нужно записать в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Количество байтов для записи. Должно удовлетворять условию 0 \< byteLength \<= 6.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает byteLength байтов value в buf с указанным offset в формате big-endian. Поддерживает точность до 48 бит. Поведение не определено, если value является чем-либо, кроме целого числа без знака.

Эта функция также доступна под псевдонимом writeUintBE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeUIntBE(0x1234567890ab, 0, 6)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer 12 34 56 78 90 ab>

buf.writeUIntLE(value, offset, byteLength)

[История]

Версия	Изменения
v14.9.0, v12.19.0	Эта функция также доступна как buf.writeUintLE().
v10.0.0	Удалены noAssert и неявное приведение смещения и byteLength к uint32.
v0.5.5	Добавлено в: v0.5.5

• value <integer> Число, которое нужно записать в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 \<= offset \<= buf.length - byteLength.
• byteLength <integer> Количество байтов для записи. Должно удовлетворять условию 0 \< byteLength \<= 6.
• Возвращает: <integer> offset плюс количество записанных байтов.

Записывает byteLength байтов value в buf с указанным offset в формате little-endian. Поддерживает точность до 48 бит. Поведение не определено, если value является чем-либо, кроме целого числа без знака.

Эта функция также доступна под псевдонимом writeUintLE.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeUIntLE(0x1234567890ab, 0, 6)

console.log(buf)
// Выводит: <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)
// Выводит: <Buffer ab 90 78 56 34 12>

new Buffer(array)

[История]

Версия	Изменения
v10.0.0	Вызов этого конструктора выдает предупреждение об устаревании при запуске из кода вне каталога node_modules.
v7.2.1	Вызов этого конструктора больше не выдает предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь выдает предупреждение об устаревании.
v6.0.0	Устарел с версии: v6.0.0

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело: Используйте Buffer.from(array) вместо этого.

• array <integer[]> Массив байтов для копирования.

См. Buffer.from(array).

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

[История]

Версия	Изменения
v10.0.0	Вызов этого конструктора выдает предупреждение об устаревании при запуске из кода вне каталога node_modules.
v7.2.1	Вызов этого конструктора больше не выдает предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь выдает предупреждение об устаревании.
v6.0.0	Теперь поддерживаются параметры byteOffset и length.
v6.0.0	Устарел с версии: v6.0.0
v3.0.0	Добавлено в: v3.0.0

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело: Используйте Buffer.from(arrayBuffer[, byteOffset[, length]]) вместо этого.

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> ArrayBuffer, SharedArrayBuffer или свойство .buffer TypedArray.
• byteOffset <integer> Индекс первого байта для отображения. По умолчанию: 0.
• length <integer> Количество байтов для отображения. По умолчанию: arrayBuffer.byteLength - byteOffset.

См. Buffer.from(arrayBuffer[, byteOffset[, length]]).

new Buffer(buffer)

[История]

Версия	Изменения
v10.0.0	Вызов этого конструктора выдает предупреждение об устаревании при запуске из кода за пределами каталога node_modules.
v7.2.1	Вызов этого конструктора больше не выдает предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь выдает предупреждение об устаревании.
v6.0.0	Устарело с версии: v6.0.0

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело: Используйте Buffer.from(buffer) вместо этого.

• buffer <Buffer> | <Uint8Array> Существующий Buffer или Uint8Array, из которого копируются данные.

См. Buffer.from(buffer).

new Buffer(size)

[История]

Версия	Изменения
v10.0.0	Вызов этого конструктора выдает предупреждение об устаревании при запуске из кода за пределами каталога node_modules.
v8.0.0	new Buffer(size) по умолчанию возвращает память, заполненную нулями.
v7.2.1	Вызов этого конструктора больше не выдает предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь выдает предупреждение об устаревании.
v6.0.0	Устарело с версии: v6.0.0

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело: Используйте Buffer.alloc() вместо этого (также см. Buffer.allocUnsafe()).

• size <integer> Желаемая длина нового Buffer.

См. Buffer.alloc() и Buffer.allocUnsafe(). Этот вариант конструктора эквивалентен Buffer.alloc().

new Buffer(string[, encoding])

[История]

Версия	Изменения
v10.0.0	Вызов этого конструктора выдает предупреждение об устаревании при запуске из кода вне каталога node_modules.
v7.2.1	Вызов этого конструктора больше не выдает предупреждения об устаревании.
v7.0.0	Вызов этого конструктора теперь выдает предупреждение об устаревании.
v6.0.0	Устарело с версии: v6.0.0

[Стабильно: 0 - Устарело]

Стабильно: 0 Стабильность: 0 - Устарело: Используйте Buffer.from(string[, encoding]) вместо этого.

• string <строка> Строка для кодирования.
• encoding <строка> Кодировка string. По умолчанию: 'utf8'.

См. Buffer.from(string[, encoding]).

Класс: File

[История]

Версия	Изменения
v23.0.0	Делает экземпляры File клонируемыми.
v20.0.0	Больше не является экспериментальным.
v19.2.0, v18.13.0	Добавлено в: v19.2.0, v18.13.0

• Расширяет: <Blob>

File предоставляет информацию о файлах.

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

Добавлено в: v19.2.0, v18.13.0

• sources <строка[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> | <File[]> Массив строк, объектов <ArrayBuffer>, <TypedArray>, <DataView>, <File> или <Blob> или любое сочетание таких объектов, которые будут храниться внутри File.
• fileName <строка> Имя файла.
• options <Объект>
  • endings <строка> Одно из двух: 'transparent' или 'native'. Когда установлено значение 'native', окончания строк в строковых исходных частях будут преобразованы в собственное окончание строки платформы, как указано в require('node:os').EOL.
  • type <строка> Тип содержимого файла.
  • lastModified <число> Дата последнего изменения файла. По умолчанию: Date.now().

file.name

Добавлено в: v19.2.0, v18.13.0

• Тип: <string>

Имя File.

file.lastModified

Добавлено в: v19.2.0, v18.13.0

• Тип: <number>

Дата последнего изменения File.

API модуля node:buffer

Хотя объект Buffer доступен как глобальный, существуют дополнительные API, связанные с Buffer, которые доступны только через модуль node:buffer, к которому можно получить доступ с помощью require('node:buffer').

buffer.atob(data)

Добавлено в: v15.13.0, v14.17.0

[Стабильность: 3 - Устаревший]

Стабильность: 3 Стабильность: 3 - Устаревший. Используйте Buffer.from(data, 'base64') вместо этого.

• data <any> Строка ввода в кодировке Base64.

Декодирует строку данных в кодировке Base64 в байты и кодирует эти байты в строку, используя Latin-1 (ISO-8859-1).

data может быть любым значением JavaScript, которое может быть приведено к строке.

Эта функция предоставляется только для совместимости с устаревшими API веб-платформы и никогда не должна использоваться в новом коде, поскольку они используют строки для представления двоичных данных и предшествуют появлению типизированных массивов в JavaScript. Для кода, работающего с использованием API Node.js, преобразование между строками в кодировке base64 и двоичными данными следует выполнять с помощью Buffer.from(str, 'base64') и buf.toString('base64').

buffer.btoa(data)

Добавлено в: v15.13.0, v14.17.0

[Стабильность: 3 - Устаревший]

Стабильность: 3 Стабильность: 3 - Устаревший. Используйте buf.toString('base64') вместо этого.

• data <any> Строка ASCII (Latin1).

Декодирует строку в байты, используя Latin-1 (ISO-8859), и кодирует эти байты в строку, используя Base64.

data может быть любым значением JavaScript, которое может быть приведено к строке.

Эта функция предоставляется только для совместимости с устаревшими API веб-платформы и никогда не должна использоваться в новом коде, поскольку они используют строки для представления двоичных данных и предшествуют появлению типизированных массивов в JavaScript. Для кода, работающего с использованием API Node.js, преобразование между строками в кодировке base64 и двоичными данными следует выполнять с помощью Buffer.from(str, 'base64') и buf.toString('base64').

buffer.isAscii(input)

Добавлено в: v19.6.0, v18.15.0

• input <Buffer> | <ArrayBuffer> | <TypedArray> Ввод для проверки.
• Возвращает: <boolean>

Эта функция возвращает true, если input содержит только допустимые данные в кодировке ASCII, включая случай, когда input пуст.

Выбрасывает исключение, если input является отсоединенным буфером массива.

buffer.isUtf8(input)

Добавлено в: v19.4.0, v18.14.0

• input <Buffer> | <ArrayBuffer> | <TypedArray> Ввод для проверки.
• Возвращает: <boolean>

Эта функция возвращает true, если input содержит только допустимые данные в кодировке UTF-8, включая случай, когда input пуст.

Выбрасывает исключение, если input является отсоединенным буфером массива.

buffer.INSPECT_MAX_BYTES

Добавлено в: v0.5.4

• <integer> По умолчанию: 50

Возвращает максимальное количество байтов, которое будет возвращено при вызове buf.inspect(). Это можно переопределить пользовательскими модулями. Подробнее о поведении buf.inspect() см. util.inspect().

buffer.kMaxLength

Добавлено в: v3.0.0

• <integer> Максимальный размер, допустимый для одного экземпляра Buffer.

Псевдоним для buffer.constants.MAX_LENGTH.

buffer.kStringMaxLength

Добавлено в: v3.0.0

• <integer> Максимальная длина, допустимая для одного экземпляра string.

Псевдоним для buffer.constants.MAX_STRING_LENGTH.

buffer.resolveObjectURL(id)

Добавлено в: v16.7.0

[Stable: 1 - Experimental]

Стабильность: 1 Стабильность: 1 - Экспериментальное

• id <string> Строка URL-адреса 'blob:nodedata:..., возвращенная предыдущим вызовом URL.createObjectURL().
• Возвращает: <Blob>

Разрешает 'blob:nodedata:...' связанный объект <Blob>, зарегистрированный с помощью предыдущего вызова URL.createObjectURL().

buffer.transcode(source, fromEnc, toEnc)

[История]

Версия	Изменения
v8.0.0	Параметр source теперь может быть Uint8Array.
v7.1.0	Добавлено в: v7.1.0

• source <Buffer> | <Uint8Array> Экземпляр Buffer или Uint8Array.
• fromEnc <string> Текущая кодировка.
• toEnc <string> Целевая кодировка.
• Возвращает: <Buffer>

Перекодирует заданный экземпляр Buffer или Uint8Array из одной кодировки символов в другую. Возвращает новый экземпляр Buffer.

Выбрасывает ошибку, если fromEnc или toEnc указывают недопустимые кодировки символов или если преобразование из fromEnc в toEnc не разрешено.

Кодировки, поддерживаемые buffer.transcode(): 'ascii', 'utf8', 'utf16le', 'ucs2', 'latin1' и 'binary'.

В процессе транскодирования будут использоваться символы замены, если заданная последовательность байтов не может быть адекватно представлена в целевой кодировке. Например:

ESM

import { Buffer, transcode } from 'node:buffer'

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Выводит: '?'

CJS

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

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Выводит: '?'

Поскольку символ евро (€) не может быть представлен в US-ASCII, он заменяется на ? в транскодированном Buffer.

Класс: SlowBuffer

Устарело с версии: v6.0.0

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело: Используйте Buffer.allocUnsafeSlow() вместо этого.

См. Buffer.allocUnsafeSlow(). Это никогда не было классом в том смысле, что конструктор всегда возвращал экземпляр Buffer, а не экземпляр SlowBuffer.

new SlowBuffer(size)

Устарело с версии: v6.0.0

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело: Используйте Buffer.allocUnsafeSlow() вместо этого.

• size <integer> Желаемая длина нового SlowBuffer.

См. Buffer.allocUnsafeSlow().

Константы Buffer

Добавлено в версии: v8.2.0

buffer.constants.MAX_LENGTH

[История]

Версия	Изменения
v22.0.0	Значение изменено на 232 - 1 на 64-битных архитектурах.
v15.0.0	Значение изменено на 231 на 64-битных архитектурах.
v14.0.0	Значение изменено с 231 - 1 на 232 - 1 на 64-битных архитектурах.
v8.2.0	Добавлено в версии: v8.2.0

• <integer> Максимальный размер, разрешенный для одного экземпляра Buffer.

На 32-битных архитектурах это значение в настоящее время равно 2³¹ - 1 (примерно 1 ГиБ).

На 64-битных архитектурах это значение в настоящее время равно 2⁵³ - 1 (примерно 8 ПиБ).

Это отражает v8::TypedArray::kMaxLength под капотом.

Это значение также доступно как buffer.kMaxLength.

buffer.constants.MAX_STRING_LENGTH

Добавлено в версии: v8.2.0

• <integer> Максимальная длина, разрешенная для одного экземпляра string.

Представляет наибольшую length, которую может иметь примитив string, подсчитанную в кодовых единицах UTF-16.

Это значение может зависеть от используемого движка JS.

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

В версиях Node.js до 6.0.0 экземпляры Buffer создавались с помощью функции конструктора Buffer, которая выделяет возвращаемый Buffer по-разному, в зависимости от предоставленных аргументов:

• Передача числа в качестве первого аргумента в Buffer() (например, new Buffer(10)) выделяет новый объект Buffer указанного размера. До Node.js 8.0.0 память, выделенная для таких экземпляров Buffer, не инициализируется и может содержать конфиденциальные данные. Такие экземпляры Buffer должны быть впоследствии инициализированы путем использования либо buf.fill(0), либо записи во весь Buffer перед чтением данных из Buffer. Хотя такое поведение намеренно для повышения производительности, опыт разработки показал, что требуется более явное различие между созданием быстрого, но неинициализированного Buffer, и созданием более медленного, но безопасного Buffer. Начиная с Node.js 8.0.0, Buffer(num) и new Buffer(num) возвращают Buffer с инициализированной памятью.
• Передача строки, массива или Buffer в качестве первого аргумента копирует данные переданного объекта в Buffer.
• Передача ArrayBuffer или SharedArrayBuffer возвращает Buffer, который разделяет выделенную память с заданным буфером массива.

Поскольку поведение new Buffer() отличается в зависимости от типа первого аргумента, проблемы безопасности и надежности могут быть непреднамеренно внесены в приложения, когда не выполняется проверка аргументов или инициализация Buffer.

Например, если злоумышленник может заставить приложение получить число там, где ожидается строка, приложение может вызвать new Buffer(100) вместо new Buffer("100"), что приведет к выделению 100-байтового буфера вместо выделения 3-байтового буфера с содержимым "100". Это часто возможно при использовании вызовов JSON API. Поскольку JSON различает числовые и строковые типы, он позволяет внедрять числа там, где наивно написанное приложение, которое недостаточно проверяет свой ввод, может ожидать всегда получать строку. До Node.js 8.0.0 100-байтовый буфер мог содержать произвольные ранее существовавшие данные в памяти, поэтому мог использоваться для раскрытия секретов в памяти удаленному злоумышленнику. Начиная с Node.js 8.0.0, утечка памяти невозможна, потому что данные заполнены нулями. Однако возможны и другие атаки, такие как вызов выделения очень больших буферов на сервере, что приводит к снижению производительности или сбою из-за нехватки памяти.

Чтобы сделать создание экземпляров Buffer более надежным и менее подверженным ошибкам, различные формы конструктора new Buffer() были устаревшими и заменены отдельными методами Buffer.from(), Buffer.alloc() и Buffer.allocUnsafe().

Разработчики должны перенести все существующие использования конструкторов new Buffer() в один из этих новых API.

• Buffer.from(array) возвращает новый Buffer, который содержит копию предоставленных октетов.
• Buffer.from(arrayBuffer[, byteOffset[, length]]) возвращает новый Buffer, который использует ту же выделенную память, что и заданный ArrayBuffer.
• Buffer.from(buffer) возвращает новый Buffer, который содержит копию содержимого заданного Buffer.
• Buffer.from(string[, encoding]) возвращает новый Buffer, который содержит копию предоставленной строки.
• Buffer.alloc(size[, fill[, encoding]]) возвращает новый инициализированный Buffer указанного размера. Этот метод медленнее, чем Buffer.allocUnsafe(size), но гарантирует, что вновь созданные экземпляры Buffer никогда не будут содержать старые данные, которые могут быть конфиденциальными. Если size не является числом, будет выдана ошибка TypeError.
• Buffer.allocUnsafe(size) и Buffer.allocUnsafeSlow(size) каждый возвращает новый неинициализированный Buffer указанного size. Поскольку Buffer не инициализирован, выделенный сегмент памяти может содержать старые данные, которые могут быть конфиденциальными.

Экземпляры Buffer, возвращенные Buffer.allocUnsafe(), Buffer.from(string), Buffer.concat() и Buffer.from(array) могут выделяться из общего внутреннего пула памяти, если size меньше или равно половине Buffer.poolSize. Экземпляры, возвращенные Buffer.allocUnsafeSlow(), никогда не используют общий внутренний пул памяти.

Параметр командной строки --zero-fill-buffers

Добавлено в: v5.10.0

Node.js можно запустить с параметром командной строки --zero-fill-buffers, чтобы все вновь выделенные экземпляры Buffer по умолчанию при создании заполнялись нулями. Без этого параметра буферы, созданные с помощью Buffer.allocUnsafe(), Buffer.allocUnsafeSlow() и new SlowBuffer(size), не заполняются нулями. Использование этого флага может оказать заметное негативное влияние на производительность. Используйте параметр --zero-fill-buffers только тогда, когда это необходимо, чтобы гарантировать, что вновь выделенные экземпляры Buffer не могут содержать старые данные, которые потенциально могут быть конфиденциальными.

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

Что делает Buffer.allocUnsafe() и Buffer.allocUnsafeSlow() "небезопасными"?

При вызове Buffer.allocUnsafe() и Buffer.allocUnsafeSlow() выделенный сегмент памяти не инициализируется (он не заполняется нулями). Хотя такая конструкция делает выделение памяти достаточно быстрым, выделенный сегмент памяти может содержать старые данные, которые потенциально могут быть конфиденциальными. Использование Buffer, созданного с помощью Buffer.allocUnsafe() без полной перезаписи памяти, может привести к утечке этих старых данных при чтении памяти Buffer.

Хотя использование Buffer.allocUnsafe() имеет явные преимущества в производительности, необходимо проявлять особую осторожность, чтобы избежать появления уязвимостей безопасности в приложении.