Буфер

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

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

Хотя класс Buffer доступен в глобальной области видимости, всё же рекомендуется явно обращаться к нему с помощью инструкции import или require.

import { Buffer } from 'node:buffer';

// Creates a zero-filled Buffer of length 10.
const buf1 = Buffer.alloc(10);

// Creates a Buffer of length 10,
// filled with bytes which all have the value `1`.
const buf2 = Buffer.alloc(10, 1);

// Creates an uninitialized buffer of length 10.
// This is faster than calling Buffer.alloc() but the returned
// Buffer instance might contain old data that needs to be
// overwritten using fill(), write(), or other functions that fill the Buffer's
// contents.
const buf3 = Buffer.allocUnsafe(10);

// Creates a Buffer containing the bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3]);

// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries
// are all truncated using `(value & 255)` to fit into the range 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1']);

// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
// [116, 195, 169, 115, 116] (in decimal notation)
const buf6 = Buffer.from('tést');

// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1');

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

// Creates a zero-filled Buffer of length 10.
const buf1 = Buffer.alloc(10);

// Creates a Buffer of length 10,
// filled with bytes which all have the value `1`.
const buf2 = Buffer.alloc(10, 1);

// Creates an uninitialized buffer of length 10.
// This is faster than calling Buffer.alloc() but the returned
// Buffer instance might contain old data that needs to be
// overwritten using fill(), write(), or other functions that fill the Buffer's
// contents.
const buf3 = Buffer.allocUnsafe(10);

// Creates a Buffer containing the bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3]);

// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries
// are all truncated using `(value & 255)` to fit into the range 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1']);

// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
// [116, 195, 169, 115, 116] (in decimal notation)
const buf6 = Buffer.from('tést');

// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1');

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

console.log(Buffer.from('fhqwhgads', 'utf8'));
// Prints: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'));
// Prints: <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-адресов и имён файлов алфавит», определённый в 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 эти кодовые точки поддерживаются всегда.

import { Buffer } from 'node:buffer';

Buffer.from('1ag123', 'hex');
// Prints <Buffer 1a>, data truncated when first non-hexadecimal value
// ('g') encountered.

Buffer.from('1a7', 'hex');
// Prints <Buffer 1a>, data truncated when data ends in single digit ('7').

Buffer.from('1634', 'hex');
// Prints <Buffer 16 34>, all data represented.

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

Buffer.from('1ag123', 'hex');
// Prints <Buffer 1a>, data truncated when first non-hexadecimal value
// ('g') encountered.

Buffer.from('1a7', 'hex');
// Prints <Buffer 1a>, data truncated when data ends in single digit ('7').

Buffer.from('1634', 'hex');
// Prints <Buffer 16 34>, all data represented.

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

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

Экземпляры Buffer также являются экземплярами JavaScript-классов <Uint8Array> и <TypedArray>. Все методы и свойства <TypedArray> доступны для Buffer. Однако между API Buffer и API <TypedArray> есть тонкие различия.

В частности:

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(uint32array);

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

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

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

console.log(uint32array);

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

• Передача базового <ArrayBuffer> объекта Buffer создаст <TypedArray>, использующий общую с Buffer область памяти.

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

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

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

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

console.log(uint16array);

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

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

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(2);

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

// Copies the contents of `arr`.
const buf1 = Buffer.from(arr);

// Shares memory with `arr`.
const buf2 = Buffer.from(arr.buffer);

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

arr[1] = 6000;

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

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

const arr = new Uint16Array(2);

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

// Copies the contents of `arr`.
const buf1 = Buffer.from(arr);

// Shares memory with `arr`.
const buf2 = Buffer.from(arr.buffer);

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

arr[1] = 6000;

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.length);
// Prints: 16

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

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

console.log(buf.length);
// Prints: 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 можно вызывать для экземпляров Uint8Array

Все методы прототипа Buffer можно вызывать для экземпляра Uint8Array.

const { toString, write } = Buffer.prototype;

const uint8array = new Uint8Array(5);

write.call(uint8array, 'hello', 0, 5, 'utf8'); // 5
// <Uint8Array 68 65 6c 6c 6f>

toString.call(uint8array, 'utf8'); // 'hello'
jscopy

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

Класс: Blob

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

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

• 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()

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

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

blob.bytes()

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

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

blob.size

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

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

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

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

blob.stream()

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

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

blob.text()

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

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

blob.type

• Тип: <string>

Тип содержимого Blob.

Объекты Blob и MessageChannel

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

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

// The Blob is still usable after posting.
blob.text().then(console.log);

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

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

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

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

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

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

// The Blob is still usable after posting.
blob.text().then(console.log);

Класс: Buffer

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5);

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

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

const buf = Buffer.alloc(5);

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(10);

console.log(buf);
// Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0);

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

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

const buf = Buffer.allocUnsafe(10);

console.log(buf);
// Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0);

console.log(buf);
// Prints: <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)

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

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

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

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

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

import { Buffer } from 'node:buffer';

// Need to keep around a few small chunks of memory.
const store = [];

socket.on('readable', () => {
  let data;
  while (null !== (data = readable.read())) {
    // Allocate for retained data.
    const sb = Buffer.allocUnsafeSlow(10);

    // Copy the data into the new allocation.
    data.copy(sb, 0, 0, 10);

    store.push(sb);
  }
});

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

// Need to keep around a few small chunks of memory.
const store = [];

socket.on('readable', () => {
  let data;
  while (null !== (data = readable.read())) {
    // Allocate for retained data.
    const sb = Buffer.allocUnsafeSlow(10);

    // Copy the data into the new allocation.
    data.copy(sb, 0, 0, 10);

    store.push(sb);
  }
});

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

Если string — это <Buffer> | <DataView> | <TypedArray> | <ArrayBuffer> | <SharedArrayBuffer>, возвращается длина в байтах, указанная в .byteLength.

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

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

Сравнивает buf1 с buf2, обычно для сортировки массивов экземпляров Buffer. Это эквивалентно вызову buf1.compare(buf2).

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));
// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (This result is equal to: [buf2, buf1].)

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

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

console.log(arr.sort(Buffer.compare));
// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (This result is equal to: [buf2, buf1].)

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

• 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, оставшееся пространство заполняется нулями.

import { Buffer } from 'node:buffer';

// Create a single `Buffer` from a list of three `Buffer` instances.

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);
// Prints: 42

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

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

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

// Create a single `Buffer` from a list of three `Buffer` instances.

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);
// Prints: 42

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

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

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

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

• 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
jscopy

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

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

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

import { Buffer } from 'node:buffer';

// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);

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

// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(2);

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

// Shares memory with `arr`.
const buf = Buffer.from(arr.buffer);

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

// Changing the original Uint16Array changes the Buffer also.
arr[1] = 6000;

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

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

const arr = new Uint16Array(2);

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

// Shares memory with `arr`.
const buf = Buffer.from(arr.buffer);

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

// Changing the original Uint16Array changes the Buffer also.
arr[1] = 6000;

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.length);
// Prints: 2

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

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

console.log(buf.length);
// Prints: 2

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

buf1[0] = 0x61;

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

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

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

buf1[0] = 0x61;

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

Для объектов, поддерживающих Symbol.toPrimitive, возвращается Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding).

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

console.log(Buffer.isEncoding(''));
// Prints: false

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

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

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

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

console.log(Buffer.isEncoding(''));
// Prints: false

Buffer.poolSize

• Тип: <integer> По умолчанию: 65536

Размер (в байтах) предварительно выделенных внутренних экземпляров 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.

import { Buffer } from 'node:buffer';

// Copy an ASCII string into a `Buffer` one byte at a time.
// (This only works for ASCII-only strings. In general, one should use
// `Buffer.from()` to perform this conversion.)

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

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

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

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

// Copy an ASCII string into a `Buffer` one byte at a time.
// (This only works for ASCII-only strings. In general, one should use
// `Buffer.from()` to perform this conversion.)

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

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

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

buf.buffer

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

Этот ArrayBuffer не обязательно точно соответствует исходному Buffer. Подробности см. в примечаниях к buf.byteOffset.

import { Buffer } from 'node:buffer';

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

console.log(buffer.buffer === arrayBuffer);
// Prints: true

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

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

console.log(buffer.buffer === arrayBuffer);
// Prints: true

buf.byteOffset

• Тип: <integer> Смещение byteOffset базового объекта ArrayBuffer объекта Buffer.

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

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

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

import { Buffer } from 'node:buffer';

// Create a buffer smaller than `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

// When casting the Node.js Buffer to an Int8Array, use the byteOffset
// to refer only to the part of `nodeBuffer.buffer` that contains the memory
// for `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);

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

// Create a buffer smaller than `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

// When casting the Node.js Buffer to an Int8Array, use the byteOffset
// to refer only to the part of `nodeBuffer.buffer` that contains the memory
// for `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);

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

• 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.

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));
// Prints: 0
console.log(buf1.compare(buf2));
// Prints: -1
console.log(buf1.compare(buf3));
// Prints: -1
console.log(buf2.compare(buf1));
// Prints: 1
console.log(buf2.compare(buf3));
// Prints: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare));
// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (This result is equal to: [buf1, buf3, buf2].)

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

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

console.log(buf1.compare(buf1));
// Prints: 0
console.log(buf1.compare(buf2));
// Prints: -1
console.log(buf1.compare(buf3));
// Prints: -1
console.log(buf2.compare(buf1));
// Prints: 1
console.log(buf2.compare(buf3));
// Prints: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare));
// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (This result is equal to: [buf1, buf3, buf2].)

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

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

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

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

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

Если targetStart < 0, sourceStart < 0, targetEnd > target.byteLength или sourceEnd > source.byteLength, выбрасывается ERR_OUT_OF_RANGE.

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

• 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, включая Buffer Node.js, хотя принимает другие аргументы функции.

import { Buffer } from 'node:buffer';

// Create two `Buffer` instances.
const buf1 = Buffer.allocUnsafe(26);
const buf2 = Buffer.allocUnsafe(26).fill('!');

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.
buf1.copy(buf2, 8, 16, 20);
// This is equivalent to:
// buf2.set(buf1.subarray(16, 20), 8);

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

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

// Create two `Buffer` instances.
const buf1 = Buffer.allocUnsafe(26);
const buf2 = Buffer.allocUnsafe(26).fill('!');

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.
buf1.copy(buf2, 8, 16, 20);
// This is equivalent to:
// buf2.set(buf1.subarray(16, 20), 8);

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

import { Buffer } from 'node:buffer';

// Create a `Buffer` and copy data from one region to an overlapping region
// within the same `Buffer`.

const buf = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf[i] = i + 97;
}

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

console.log(buf.toString());
// Prints: efghijghijklmnopqrstuvwxyz

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

// Create a `Buffer` and copy data from one region to an overlapping region
// within the same `Buffer`.

const buf = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf[i] = i + 97;
}

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

console.log(buf.toString());
// Prints: efghijghijklmnopqrstuvwxyz

buf.entries()

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

Создает и возвращает итератор пар [index, byte] из содержимого buf.

import { Buffer } from 'node:buffer';

// Log the entire contents of a `Buffer`.

const buf = Buffer.from('buffer');

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

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

// Log the entire contents of a `Buffer`.

const buf = Buffer.from('buffer');

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

buf.equals(otherBuffer)

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

Возвращает true, если buf и otherBuffer содержат в точности одинаковые байты, и false в противном случае. Эквивалентно buf.compare(otherBuffer) === 0.

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

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

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

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

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

• 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:

import { Buffer } from 'node:buffer';

// Fill a `Buffer` with the ASCII character 'h'.

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

console.log(b.toString());
// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Fill a buffer with empty string
const c = Buffer.allocUnsafe(5).fill('');

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

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

// Fill a `Buffer` with the ASCII character 'h'.

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

console.log(b.toString());
// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Fill a buffer with empty string
const c = Buffer.allocUnsafe(5).fill('');

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

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

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

import { Buffer } from 'node:buffer';

// Fill a `Buffer` with character that takes up two bytes in UTF-8.

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

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

// Fill a `Buffer` with character that takes up two bytes in UTF-8.

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(5);

console.log(buf.fill('a'));
// Prints: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'));
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'));
// Throws an exception.

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

const buf = Buffer.allocUnsafe(5);

console.log(buf.fill('a'));
// Prints: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'));
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'));
// Throws an exception.

buf.includes(value[, start[, end]][, encoding])

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.includes('this'));
// Prints: true
console.log(buf.includes('is'));
// Prints: true
console.log(buf.includes(Buffer.from('a buffer')));
// Prints: true
console.log(buf.includes(97));
// Prints: true (97 is the decimal ASCII value for 'a')
console.log(buf.includes(Buffer.from('a buffer example')));
// Prints: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
// Prints: true
console.log(buf.includes('this', 4));
// Prints: false

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

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

console.log(buf.includes('this'));
// Prints: true
console.log(buf.includes('is'));
// Prints: true
console.log(buf.includes(Buffer.from('a buffer')));
// Prints: true
console.log(buf.includes(97));
// Prints: true (97 is the decimal ASCII value for 'a')
console.log(buf.includes(Buffer.from('a buffer example')));
// Prints: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
// Prints: true
console.log(buf.includes('this', 4));
// Prints: false

buf.indexOf(value[, start[, end]][, encoding])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.indexOf('this'));
// Prints: 0
console.log(buf.indexOf('is'));
// Prints: 2
console.log(buf.indexOf(Buffer.from('a buffer')));
// Prints: 8
console.log(buf.indexOf(97));
// Prints: 8 (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')));
// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
// Prints: 8

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

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

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

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

console.log(buf.indexOf('this'));
// Prints: 0
console.log(buf.indexOf('is'));
// Prints: 2
console.log(buf.indexOf(Buffer.from('a buffer')));
// Prints: 8
console.log(buf.indexOf(97));
// Prints: 8 (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')));
// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
// Prints: 8

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

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

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

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

import { Buffer } from 'node:buffer';

const b = Buffer.from('abcdef');

// Passing a value that's a number, but not a valid byte.
// Prints: 2, equivalent to searching for 99 or 'c'.
console.log(b.indexOf(99.9));
console.log(b.indexOf(256 + 99));

// Passing a byteOffset that coerces to NaN or 0.
// Prints: 1, searching the whole buffer.
console.log(b.indexOf('b', undefined));
console.log(b.indexOf('b', {}));
console.log(b.indexOf('b', null));
console.log(b.indexOf('b', []));

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

const b = Buffer.from('abcdef');

// Passing a value that's a number, but not a valid byte.
// Prints: 2, equivalent to searching for 99 or 'c'.
console.log(b.indexOf(99.9));
console.log(b.indexOf(256 + 99));

// Passing a byteOffset that coerces to NaN or 0.
// Prints: 1, searching the whole buffer.
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()

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.from('buffer');

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

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

const buf = Buffer.from('buffer');

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

buf.lastIndexOf(value[, start[, end]][, encoding])

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.lastIndexOf('this'));
// Prints: 0
console.log(buf.lastIndexOf('buffer'));
// Prints: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')));
// Prints: 17
console.log(buf.lastIndexOf(97));
// Prints: 15 (97 is the decimal ASCII value for 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')));
// Prints: -1
console.log(buf.lastIndexOf('buffer', 5));
// Prints: 5
console.log(buf.lastIndexOf('buffer', 4));
// Prints: -1

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

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

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

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

console.log(buf.lastIndexOf('this'));
// Prints: 0
console.log(buf.lastIndexOf('buffer'));
// Prints: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')));
// Prints: 17
console.log(buf.lastIndexOf(97));
// Prints: 15 (97 is the decimal ASCII value for 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')));
// Prints: -1
console.log(buf.lastIndexOf('buffer', 5));
// Prints: 5
console.log(buf.lastIndexOf('buffer', 4));
// Prints: -1

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

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

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

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

import { Buffer } from 'node:buffer';

const b = Buffer.from('abcdef');

// Passing a value that's a number, but not a valid byte.
// Prints: 2, equivalent to searching for 99 or 'c'.
console.log(b.lastIndexOf(99.9));
console.log(b.lastIndexOf(256 + 99));

// Passing a byteOffset that coerces to NaN.
// Prints: 1, searching the whole buffer.
console.log(b.lastIndexOf('b', undefined));
console.log(b.lastIndexOf('b', {}));

// Passing a byteOffset that coerces to 0.
// Prints: -1, equivalent to passing 0.
console.log(b.lastIndexOf('b', null));
console.log(b.lastIndexOf('b', []));

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

const b = Buffer.from('abcdef');

// Passing a value that's a number, but not a valid byte.
// Prints: 2, equivalent to searching for 99 or 'c'.
console.log(b.lastIndexOf(99.9));
console.log(b.lastIndexOf(256 + 99));

// Passing a byteOffset that coerces to NaN.
// Prints: 1, searching the whole buffer.
console.log(b.lastIndexOf('b', undefined));
console.log(b.lastIndexOf('b', {}));

// Passing a byteOffset that coerces to 0.
// Prints: -1, equivalent to passing 0.
console.log(b.lastIndexOf('b', null));
console.log(b.lastIndexOf('b', []));

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

buf.length

• Тип: <integer>

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

import { Buffer } from 'node:buffer';

// Create a `Buffer` and write a shorter string to it using UTF-8.

const buf = Buffer.alloc(1234);

console.log(buf.length);
// Prints: 1234

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

console.log(buf.length);
// Prints: 1234

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

// Create a `Buffer` and write a shorter string to it using UTF-8.

const buf = Buffer.alloc(1234);

console.log(buf.length);
// Prints: 1234

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

console.log(buf.length);
// Prints: 1234

buf.parent

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

buf.readBigInt64BE([offset])

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

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

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

buf.readBigInt64LE([offset])

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

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

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

buf.readBigUInt64BE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

buf.readBigUInt64LE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

buf.readDoubleBE([offset])

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

buf.readDoubleLE([offset])

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readDoubleLE(0));
// Prints: 5.447603722011605e-270
console.log(buf.readDoubleLE(1));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readDoubleLE(0));
// Prints: 5.447603722011605e-270
console.log(buf.readDoubleLE(1));
// Throws ERR_OUT_OF_RANGE.

buf.readFloatBE([offset])

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

buf.readFloatLE([offset])

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readFloatLE(0));
// Prints: 1.539989614439558e-36
console.log(buf.readFloatLE(1));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readFloatLE(0));
// Prints: 1.539989614439558e-36
console.log(buf.readFloatLE(1));
// Throws ERR_OUT_OF_RANGE.

buf.readInt8([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readInt8(0));
// Prints: -1
console.log(buf.readInt8(1));
// Prints: 5
console.log(buf.readInt8(2));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readInt8(0));
// Prints: -1
console.log(buf.readInt8(1));
// Prints: 5
console.log(buf.readInt8(2));
// Throws ERR_OUT_OF_RANGE.

buf.readInt16BE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readInt16BE(0));
// Prints: 5

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

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

console.log(buf.readInt16BE(0));
// Prints: 5

buf.readInt16LE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readInt16LE(0));
// Prints: 1280
console.log(buf.readInt16LE(1));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readInt16LE(0));
// Prints: 1280
console.log(buf.readInt16LE(1));
// Throws ERR_OUT_OF_RANGE.

buf.readInt32BE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readInt32BE(0));
// Prints: 5

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

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

console.log(buf.readInt32BE(0));
// Prints: 5

buf.readInt32LE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readInt32LE(0));
// Prints: 83886080
console.log(buf.readInt32LE(1));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readInt32LE(0));
// Prints: 83886080
console.log(buf.readInt32LE(1));
// Throws ERR_OUT_OF_RANGE.

buf.readIntBE(offset, byteLength)

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

Читает byteLength байтов из buf по указанному offset и интерпретирует результат как знаковое значение в дополнительном коде в порядке от старшего байта к младшему с точностью до 48 бит.

import { Buffer } from 'node:buffer';

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

console.log(buf.readIntBE(0, 6).toString(16));
// Prints: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16));
// Throws ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readIntBE(0, 6).toString(16));
// Prints: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16));
// Throws ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16));
// Throws ERR_OUT_OF_RANGE.

buf.readIntLE(offset, byteLength)

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

Читает byteLength байтов из buf по указанному offset и интерпретирует результат как знаковое значение в дополнительном коде в порядке от младшего байта к старшему с точностью до 48 бит.

import { Buffer } from 'node:buffer';

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

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

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

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

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

buf.readUInt8([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt8(0));
// Prints: 1
console.log(buf.readUInt8(1));
// Prints: 254
console.log(buf.readUInt8(2));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readUInt8(0));
// Prints: 1
console.log(buf.readUInt8(1));
// Prints: 254
console.log(buf.readUInt8(2));
// Throws ERR_OUT_OF_RANGE.

buf.readUInt16BE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

buf.readUInt16LE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt16LE(0).toString(16));
// Prints: 3412
console.log(buf.readUInt16LE(1).toString(16));
// Prints: 5634
console.log(buf.readUInt16LE(2).toString(16));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readUInt16LE(0).toString(16));
// Prints: 3412
console.log(buf.readUInt16LE(1).toString(16));
// Prints: 5634
console.log(buf.readUInt16LE(2).toString(16));
// Throws ERR_OUT_OF_RANGE.

buf.readUInt32BE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

buf.readUInt32LE([offset])

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt32LE(0).toString(16));
// Prints: 78563412
console.log(buf.readUInt32LE(1).toString(16));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readUInt32LE(0).toString(16));
// Prints: 78563412
console.log(buf.readUInt32LE(1).toString(16));
// Throws ERR_OUT_OF_RANGE.

buf.readUIntBE(offset, byteLength)

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

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

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

import { Buffer } from 'node:buffer';

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

console.log(buf.readUIntBE(0, 6).toString(16));
// Prints: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16));
// Throws ERR_OUT_OF_RANGE.

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

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

console.log(buf.readUIntBE(0, 6).toString(16));
// Prints: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16));
// Throws ERR_OUT_OF_RANGE.

buf.readUIntLE(offset, byteLength)

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

• start <integer> Начальная позиция нового Buffer. По умолчанию: 0.
• end <integer> Конечная позиция нового Buffer (не включая ее). По умолчанию: buf.length.
• Возвращает: <Buffer>

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

Если указать end больше buf.length, результат будет таким же, как если бы end равнялся buf.length.

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

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

import { Buffer } from 'node:buffer';

// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte
// from the original `Buffer`.

const buf1 = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

const buf2 = buf1.subarray(0, 3);

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

buf1[0] = 33;

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

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

// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte
// from the original `Buffer`.

const buf1 = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

const buf2 = buf1.subarray(0, 3);

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

buf1[0] = 33;

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

Отрицательные индексы задают срез относительно конца buf, а не его начала.

import { Buffer } from 'node:buffer';

const buf = Buffer.from('buffer');

console.log(buf.subarray(-6, -1).toString());
// Prints: buffe
// (Equivalent to buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString());
// Prints: buff
// (Equivalent to buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString());
// Prints: uff
// (Equivalent to buf.subarray(1, 4).)

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

const buf = Buffer.from('buffer');

console.log(buf.subarray(-6, -1).toString());
// Prints: buffe
// (Equivalent to buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString());
// Prints: buff
// (Equivalent to buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString());
// Prints: uff
// (Equivalent to buf.subarray(1, 4).)

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

• start <integer> Начальная позиция нового Buffer. По умолчанию: 0.
• end <integer> Конечная позиция нового Buffer (не включая ее). По умолчанию: buf.length.
• Возвращает: <Buffer>

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

Этот метод несовместим с Uint8Array.prototype.slice(), суперклассом Buffer. Чтобы скопировать срез, используйте Uint8Array.prototype.slice().

import { Buffer } from 'node:buffer';

const buf = Buffer.from('buffer');

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

console.log(buf.toString());
// Prints: buffer

// With buf.slice(), the original buffer is modified.
const notReallyCopiedBuf = buf.slice();
notReallyCopiedBuf[0]++;
console.log(notReallyCopiedBuf.toString());
// Prints: cuffer
console.log(buf.toString());
// Also prints: cuffer (!)

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

const buf = Buffer.from('buffer');

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

console.log(buf.toString());
// Prints: buffer

// With buf.slice(), the original buffer is modified.
const notReallyCopiedBuf = buf.slice();
notReallyCopiedBuf[0]++;
console.log(notReallyCopiedBuf.toString());
// Prints: cuffer
console.log(buf.toString());
// Also prints: cuffer (!)

buf.swap16()

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

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

import { Buffer } from 'node:buffer';

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

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

buf1.swap16();

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

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

buf2.swap16();
// Throws ERR_INVALID_BUFFER_SIZE.

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

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

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

buf1.swap16();

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

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

buf2.swap16();
// Throws ERR_INVALID_BUFFER_SIZE.

Удобный способ применения buf.swap16() — быстрое преобразование на месте между UTF-16 с порядком байтов от младшего к старшему и UTF-16 с порядком байтов от старшего к младшему:

import { Buffer } from 'node:buffer';

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le');
buf.swap16(); // Convert to big-endian UTF-16 text.

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

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le');
buf.swap16(); // Convert to big-endian UTF-16 text.

buf.swap32()

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

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

import { Buffer } from 'node:buffer';

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

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

buf1.swap32();

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

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

buf2.swap32();
// Throws ERR_INVALID_BUFFER_SIZE.

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

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

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

buf1.swap32();

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

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

buf2.swap32();
// Throws ERR_INVALID_BUFFER_SIZE.

buf.swap64()

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

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

import { Buffer } from 'node:buffer';

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

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

buf1.swap64();

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

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

buf2.swap64();
// Throws ERR_INVALID_BUFFER_SIZE.

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

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

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

buf1.swap64();

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

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

buf2.swap64();
// Throws ERR_INVALID_BUFFER_SIZE.

buf.toJSON()

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

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

Buffer.from() принимает объекты в формате, возвращаемом этим методом. В частности, Buffer.from(buf.toJSON()) работает так же, как Buffer.from(buf).

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

const buf1 = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

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

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

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

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

const buf1 = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

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

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

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

buf.values()

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.from('buffer');

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

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

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

const buf = Buffer.from('buffer');

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

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

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

• 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. Однако символы, закодированные не полностью, записаны не будут.

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)}`);
// Prints: 12 bytes: ½ + ¼ = ¾

const buffer = Buffer.alloc(10);

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

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

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)}`);
// Prints: 12 bytes: ½ + ¼ = ¾

const buffer = Buffer.alloc(10);

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

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

buf.writeBigInt64BE(value[, offset])

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

Записывает value в buf по указанному адресу offset в формате с прямым порядком байтов.

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64BE(0x0102030405060708n, 0);

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64BE(0x0102030405060708n, 0);

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

buf.writeBigInt64LE(value[, offset])

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

Записывает value в buf по указанному адресу offset в формате с обратным порядком байтов.

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64LE(0x0102030405060708n, 0);

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64LE(0x0102030405060708n, 0);

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

buf.writeBigUInt64BE(value[, offset])

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

Записывает value в buf по указанному адресу offset в формате с прямым порядком байтов.

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64BE(0xdecafafecacefaden, 0);

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64BE(0xdecafafecacefaden, 0);

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

buf.writeBigUInt64LE(value[, offset])

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

Записывает value в buf по указанному адресу offset в формате с обратным порядком байтов

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64LE(0xdecafafecacefaden, 0);

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64LE(0xdecafafecacefaden, 0);

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

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

buf.writeDoubleBE(value[, offset])

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleBE(123.456, 0);

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleBE(123.456, 0);

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

buf.writeDoubleLE(value[, offset])

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleLE(123.456, 0);

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleLE(123.456, 0);

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

buf.writeFloatBE(value[, offset])

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

buf.writeFloatLE(value[, offset])

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

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

buf.writeInt8(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

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

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

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

const buf = Buffer.allocUnsafe(2);

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

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

buf.writeInt16BE(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

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

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

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

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

buf.writeInt16LE(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

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

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

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

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

buf.writeInt32BE(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

console.log(buf);
// Prints: <Buffer 01 02 03 04>

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

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

console.log(buf);
// Prints: <Buffer 01 02 03 04>

buf.writeInt32LE(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32LE(0x05060708, 0);

console.log(buf);
// Prints: <Buffer 08 07 06 05>

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

const buf = Buffer.allocUnsafe(4);

buf.writeInt32LE(0x05060708, 0);

console.log(buf);
// Prints: <Buffer 08 07 06 05>

buf.writeIntBE(value, offset, byteLength)

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

buf.writeIntBE(0x1234567890ab, 0, 6);

console.log(buf);
// Prints: <Buffer 12 34 56 78 90 ab>

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

const buf = Buffer.allocUnsafe(6);

buf.writeIntBE(0x1234567890ab, 0, 6);

console.log(buf);
// Prints: <Buffer 12 34 56 78 90 ab>

buf.writeIntLE(value, offset, byteLength)

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

buf.writeIntLE(0x1234567890ab, 0, 6);

console.log(buf);
// Prints: <Buffer ab 90 78 56 34 12>

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

const buf = Buffer.allocUnsafe(6);

buf.writeIntLE(0x1234567890ab, 0, 6);

console.log(buf);
// Prints: <Buffer ab 90 78 56 34 12>

buf.writeUInt8(value[, offset])

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

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

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

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);
// Prints: <Buffer 03 04 23 42>

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt8(0x3, 0);
buf.writeUInt8(0x4, 1);
buf.writeUInt8(0x23, 2);
buf.writeUInt8(0x42, 3);

console.log(buf);
// Prints: <Buffer 03 04 23 42>

buf.writeUInt16BE(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

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

console.log(buf);
// Prints: <Buffer de ad be ef>

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

const buf = Buffer.allocUnsafe(4);

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

console.log(buf);
// Prints: <Buffer de ad be ef>

buf.writeUInt16LE(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt16LE(0xdead, 0);
buf.writeUInt16LE(0xbeef, 2);

console.log(buf);
// Prints: <Buffer ad de ef be>

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt16LE(0xdead, 0);
buf.writeUInt16LE(0xbeef, 2);

console.log(buf);
// Prints: <Buffer ad de ef be>

buf.writeUInt32BE(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

console.log(buf);
// Prints: <Buffer fe ed fa ce>

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

console.log(buf);
// Prints: <Buffer fe ed fa ce>

buf.writeUInt32LE(value[, offset])

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

console.log(buf);
// Prints: <Buffer ce fa ed fe>

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

console.log(buf);
// Prints: <Buffer ce fa ed fe>

buf.writeUIntBE(value, offset, byteLength)

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

buf.writeUIntBE(0x1234567890ab, 0, 6);

console.log(buf);
// Prints: <Buffer 12 34 56 78 90 ab>

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

const buf = Buffer.allocUnsafe(6);

buf.writeUIntBE(0x1234567890ab, 0, 6);

console.log(buf);
// Prints: <Buffer 12 34 56 78 90 ab>

buf.writeUIntLE(value, offset, byteLength)

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

buf.writeUIntLE(0x1234567890ab, 0, 6);

console.log(buf);
// Prints: <Buffer ab 90 78 56 34 12>

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

const buf = Buffer.allocUnsafe(6);

buf.writeUIntLE(0x1234567890ab, 0, 6);

console.log(buf);
// Prints: <Buffer ab 90 78 56 34 12>

new Buffer(array)

• array <integer[]> Массив байтов, из которого выполняется копирование.

См. Buffer.from(array).

new Buffer(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)

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

См. Buffer.from(buffer).

new Buffer(size)

• size <integer> Требуемая длина нового Buffer.

См. Buffer.alloc() и Buffer.allocUnsafe(). Этот вариант конструктора эквивалентен Buffer.alloc().

new Buffer(string[, encoding])

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

См. Buffer.from(string[, encoding]).

Класс: File

• Расширяет: <Blob>

Объект <File> содержит сведения о файлах.

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

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

file.name

• Тип: <string>

Имя File.

file.lastModified

• Тип: <number>

Дата последнего изменения File.

node:buffer API модуля

Хотя объект Buffer доступен как глобальный, существуют дополнительные API, связанные с Buffer, которые доступны только через модуль node:buffer, подключаемый с помощью require('node:buffer').

buffer.atob(data)

• data <any> Входная строка в кодировке Base64.

Декодирует строку с данными в кодировке Base64 в байты, а затем кодирует эти байты в строку с использованием Latin-1 (ISO-8859-1).

data может быть любым значением JavaScript, которое можно преобразовать в строку.

Эта функция предоставляется только для совместимости с устаревшими API веб-платформы и не должна использоваться в новом коде, поскольку эти API используют строки для представления двоичных данных и появились до внедрения типизированных массивов в JavaScript. В коде, использующем API Node.js, преобразование строк в кодировке Base64 и двоичных данных следует выполнять с помощью Buffer.from(str, 'base64') и buf.toString('base64').

Доступна автоматическая миграция (исходный код:

npx codemod@latest @nodejs/buffer-atob-btoa
bashcopy

buffer.btoa(data)

• data <any> Строка ASCII (Latin1).

Декодирует строку в байты с использованием Latin-1 (ISO-8859), а затем кодирует эти байты в строку с использованием Base64.

data может быть любым значением JavaScript, которое можно преобразовать в строку.

Эта функция предоставляется только для совместимости с устаревшими API веб-платформы и не должна использоваться в новом коде, поскольку эти API используют строки для представления двоичных данных и появились до внедрения типизированных массивов в JavaScript. В коде, использующем API Node.js, преобразование строк в кодировке Base64 и двоичных данных следует выполнять с помощью Buffer.from(str, 'base64') и buf.toString('base64').

Доступна автоматическая миграция (исходный код:

npx codemod@latest @nodejs/buffer-atob-btoa
bashcopy

buffer.isAscii(input)

• input <Buffer> | <ArrayBuffer> | <TypedArray> Проверяемые входные данные.
• Возвращает: <boolean>

Функция возвращает true, если input содержит только допустимые данные в кодировке ASCII, в том числе если input пуст.

Вызывает исключение, если input является отсоединённым буфером массива.

buffer.isUtf8(input)

• input <Buffer> | <ArrayBuffer> | <TypedArray> Проверяемые входные данные.
• Возвращает: <boolean>

Функция возвращает true, если input содержит только допустимые данные в кодировке UTF-8, в том числе если input пуст.

Вызывает исключение, если input является отсоединённым буфером массива.

buffer.INSPECT_MAX_BYTES

• Тип: <integer> По умолчанию: 50

Возвращает максимальное количество байтов, которое будет выведено при вызове buf.inspect(). Это значение можно переопределить в пользовательских модулях. Дополнительные сведения о поведении buf.inspect() см. в разделе util.inspect().

buffer.kMaxLength

• Тип: <integer> Максимальный допустимый размер одного экземпляра Buffer.

Псевдоним для buffer.constants.MAX_LENGTH.

buffer.kStringMaxLength

• Тип: <integer> Максимальная допустимая длина одного экземпляра string.

Псевдоним для buffer.constants.MAX_STRING_LENGTH.

buffer.resolveObjectURL(id)

• id <string> Строка URL 'blob:nodedata:..., возвращённая предыдущим вызовом URL.createObjectURL().
• Возвращает: <Blob>

Находит связанный объект <Blob> по 'blob:nodedata:...', зарегистрированному предыдущим вызовом URL.createObjectURL().

buffer.transcode(source, fromEnc, toEnc)

• 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'.

В процессе перекодирования для байтовой последовательности, которую нельзя корректно представить в целевой кодировке, используются символы замены. Например:

import { Buffer, transcode } from 'node:buffer';

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii');
console.log(newBuf.toString('ascii'));
// Prints: '?'

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

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii');
console.log(newBuf.toString('ascii'));
// Prints: '?'

Поскольку знак евро (€) нельзя представить в US-ASCII, в перекодированном Buffer он заменяется на ?.

Константы Buffer

buffer.constants.MAX_LENGTH

• Тип: <integer> Наибольший допустимый размер одного экземпляра Buffer.

В 32-разрядных архитектурах это значение равно 2³¹ - 1 (около 2 ГиБ).

В 64-разрядных архитектурах это значение равно Number.MAX_SAFE_INTEGER (2⁵³ - 1, около 8 ПиБ).

Внутри оно соответствует v8::Uint8Array::kMaxLength.

Это значение также доступно как buffer.kMaxLength.

buffer.constants.MAX_STRING_LENGTH

• Тип: <integer> Наибольшая допустимая длина одного экземпляра string.

Представляет собой наибольшую длину length, которую может иметь примитив string, измеренную в 16-разрядных кодовых единицах 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". Такое часто возможно при использовании вызовов API JSON. Поскольку 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

Node.js можно запустить с параметром командной строки --zero-fill-buffers, чтобы по умолчанию все вновь выделенные экземпляры Buffer при создании заполнялись нулями. Без этого параметра буферы, созданные с помощью Buffer.allocUnsafe() и Buffer.allocUnsafeSlow(), не заполняются нулями. Использование этого флага может заметно снизить производительность. Используйте параметр --zero-fill-buffers только при необходимости гарантировать, что вновь выделенные экземпляры Buffer не будут содержать старые потенциально конфиденциальные данные.

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

Почему Buffer.allocUnsafe() и Buffer.allocUnsafeSlow() считаются «небезопасными»?

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

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