Буфер

До появления TypedArray, в языке JavaScript не было механизма для чтения и обработки потоков двоичных данных. Класс Buffer был введён в API Node.js для взаимодействия с потоками октетов в TCP-потоках, операциях с файловой системой и других контекстах.

Сейчас, с доступностью TypedArray, класс Buffer реализует API Uint8Array более оптимизированным и подходящим для Node.js способом.

Экземпляры класса Buffer похожи на массивы целых чисел, но соответствуют выделению фиксированного объёма памяти вне кучи V8. Размер Buffer устанавливается при его создании и не может быть изменён.

Класс Buffer находится в глобальной области видимости, поэтому вряд ли понадобится использовать require('buffer').Buffer.

Примеры:

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

// Creates a Buffer of length 10, filled with 0x1.
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 either fill() or write().
const buf3 = Buffer.allocUnsafe(10);

// Creates a Buffer containing [0x1, 0x2, 0x3].
const buf4 = Buffer.from([1, 2, 3]);

// Creates a Buffer containing UTF-8 bytes [0x74, 0xc3, 0xa9, 0x73, 0x74].
const buf5 = Buffer.from('tést');

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

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

В версиях Node.js до v6, экземпляры Buffer создавались с помощью конструктора Buffer, который выделяет возвращаемый Buffer по-разному в зависимости от переданных аргументов:

• Передача числа в качестве первого аргумента к Buffer() (например, new Buffer(10)) выделяет новый объект Buffer заданного размера. До Node.js 8.0.0, память, выделенная для таких экземпляров Buffer, не инициализируется и может содержать конфиденциальные данные. Такие экземпляры Buffer обязательно должны быть инициализированы, используя buf.fill(0) или записав в Buffer полностью. Хотя это поведение намеренное для повышения производительности, опыт разработки показал, что необходима более ясная разница между быстрым, но неинициализированным Buffer и медленным, но безопасным Buffer. Начиная с Node.js 8.0.0, Buffer(num) и new Buffer(num) вернут Buffer с инициализированной памятью.
• Передача строки, массива или Buffer в качестве первого аргумента копирует данные переданного объекта в Buffer.
• Передача ArrayBuffer или SharedArrayBuffer возвращает Buffer который разделяет выделенную память с переданным массивом буфера.

Из-за существенного изменения поведения new Buffer() в зависимости от типа значения, переданного в качестве первого аргумента, приложения, не проверяющие входные аргументы, переданные new Buffer(), или не инициализирующие содержимое недавно выделенных Buffer могут случайно ввести проблемы безопасности и надёжности в свой код.

Для повышения надёжности и уменьшения ошибок при создании экземпляров 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 никогда не содержат старые и потенциально конфиденциальные данные.
• Buffer.allocUnsafe(size) и Buffer.allocUnsafeSlow(size) каждый возвращает новый Buffer заданного size, содержимое которого обязательно должно быть инициализировано с помощью buf.fill(0) или записано полностью.

Экземпляры Buffer, возвращаемые Buffer.allocUnsafe(), могут быть выделены из общего внутреннего пула памяти, если size меньше или равно половине Buffer.poolSize. Экземпляры, возвращаемые Buffer.allocUnsafeSlow(), никогда не используют общий внутренний пул памяти.

Команда --zero-fill-buffers командной строки

Node.js можно запустить с помощью опции командной строки --zero-fill-buffers для принудительной автоматической обнуления всех вновь выделенных экземпляров Buffer созданных с помощью new Buffer(size), Buffer.allocUnsafe(), Buffer.allocUnsafeSlow() или new SlowBuffer(size) при создании. Использование этого флага меняет поведение по умолчанию этих методов и может значительно повлиять на производительность. Использование опции --zero-fill-buffers рекомендуется только при необходимости для обеспечения того, что вновь выделенные экземпляры Buffer не могут содержать потенциально конфиденциальные данные.

Пример:

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

Что делает Buffer.allocUnsafe() и Buffer.allocUnsafeSlow() «небезопасными»?

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

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

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

Экземпляры Buffer часто используются для представления последовательностей закодированных символов, таких как UTF-8, UCS2, Base64 или даже данных, закодированных в шестнадцатеричном формате. Возможна конвертация между экземплярами Buffer и обычными строками JavaScript с использованием явной кодировки символов.

Пример:

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

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

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

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

• 'ascii' - Только для данных 7-битного ASCII. Эта кодировка быстрая и удалит старший бит, если он установлен.

• 'utf8' - Многобайтовые закодированные символы Юникода. Многие веб-страницы и другие форматы документов используют UTF-8.

• 'utf16le' - 2 или 4 байта, закодированные символы Юникода в формате little-endian. Поддерживаются пары суррогатов (U+10000 до U+10FFFF).

• 'ucs2' - Псевдоним для 'utf16le'.

• 'base64' - Кодировка Base64. При создании Buffer из строки эта кодировка также корректно принимает "URL и Filename Safe Alphabet", как указано в RFC4648, Раздел 5.

• 'latin1' - Способ кодирования Buffer в строку с однобайтовой кодировкой (как определено IANA в RFC1345, стр. 63, в качестве блока дополнения Latin-1 и управляющих кодов C0/C1).

• 'binary' - Псевдоним для 'latin1'.

• 'hex' - Кодирует каждый байт как две шестнадцатеричные цифры.

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

Буферы и TypedArray

Buffer экземпляры также являются Uint8Array экземплярами. Однако существуют незначительные несовместимости с TypedArray. Например, в то время как ArrayBuffer#slice() создаёт копию среза, реализация Buffer#slice() создаёт представление над существующим Buffer без копирования, делая Buffer#slice() гораздо более эффективной.

Также возможно создать новые TypedArray экземпляры из Buffer с такими оговорками:

1. Память объекта Buffer копируется в TypedArray, а не делится.

2. Память объекта Buffer интерпретируется как массив отдельных элементов, а не как массив байтов целевого типа. То есть new Uint32Array(Buffer.from([1, 2, 3, 4])) создаёт Uint32Array с 4 элементами [1, 2, 3, 4], а не Uint32Array с одним элементом [0x1020304] или [0x4030201].

Можно создать новый Buffer , который использует ту же выделенную память, что и экземпляр TypedArray , используя свойство объекта TypeArray .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);

// Prints: <Buffer 88 a0>
console.log(buf1);

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

arr[1] = 6000;

// Prints: <Buffer 88 a0>
console.log(buf1);

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

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

Пример:

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

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

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

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

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

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

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

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

Пример:

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

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

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

Класс: Buffer

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

new Buffer(array)

• array <integer[]> Массив байтов для копирования.

Выделяет новый Buffer , используя array октетов.

Пример:

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

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

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

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

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

Пример:

const arr = new Uint16Array(2);

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

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

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

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

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

new Buffer(buffer)

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

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

Пример:

const buf1 = new Buffer('buffer');
const buf2 = new Buffer(buf1);

buf1[0] = 0x61;

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

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

new Buffer(size)

• size <integer> Желаемая длина нового Buffer.

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

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

Пример:

const buf = new Buffer(10);

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

new Buffer(string[, encoding])

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

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

Примеры:

const buf1 = new Buffer('this is a tést');

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

// Prints: this is a tC)st
console.log(buf1.toString('ascii'));

const buf2 = new Buffer('7468697320697320612074c3a97374', 'hex');

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

Метод класса: Buffer.alloc(size[, fill[, encoding]])

• size <целое число> Желаемая длина нового буфера.
• fill <строка> | <Буфер> | <целое число> Значение для заполнения нового буфера. По умолчанию: 0.
• encoding <строка> Если fill является строкой, это ее кодировка. По умолчанию: 'utf8'.

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

Пример:

const buf = Buffer.alloc(5);

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

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

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

Пример:

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

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

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

Пример:

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

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

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

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

Метод класса: Buffer.allocUnsafe(size)

• size <целое число> Желаемая длина нового буфера.

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

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

Пример:

const buf = Buffer.allocUnsafe(10);

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

buf.fill(0);

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

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

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

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

Метод класса: Buffer.allocUnsafeSlow(size)

• size <целое число> Желаемая длина нового буфера.

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

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

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

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

Пример:

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

socket.on('readable', () => {
  const data = socket.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);
});

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

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

Метод класса: Buffer.byteLength(string[, encoding])

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

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

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

Пример:

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

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

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

Метод класса: Buffer.compare(buf1, buf2)

• buf1 <Buffer> | <Uint8Array>
• buf2 <Buffer> | <Uint8Array>
• Возвращает: <целое>

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

Пример:

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

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

Метод класса: Buffer.concat(list[, totalLength])

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

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

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

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

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

Пример: Создать один Buffer из списка из трёх экземпляров Buffer

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

// Prints: 42
console.log(totalLength);

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

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

// Prints: 42
console.log(bufA.length);

Метод класса: Buffer.from(array)

• array <Массив>

Выделяет новый Buffer, используя array октетов.

Пример:

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

Будет выброшено исключение TypeError, если array не является Array.

Метод класса: Buffer.from(arrayBuffer[, byteOffset[, length]])

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

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

Пример:

const arr = new Uint16Array(2);

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

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

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

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

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

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

Пример:

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

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

Будет выброшено исключение TypeError, если arrayBuffer не является ArrayBuffer или SharedArrayBuffer.

Метод класса: Buffer.from(buffer)

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

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

Пример:

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

buf1[0] = 0x61;

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

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

Будет выброшено исключение TypeError, если buffer не является Buffer.

Метод класса: Buffer.from(string[, encoding])

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

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

Примеры:

const buf1 = Buffer.from('this is a tést');

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

// Prints: this is a tC)st
console.log(buf1.toString('ascii'));

const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');

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

Будет выброшено исключение TypeError, если string не является строкой.

Метод класса: Buffer.from(object[, offsetOrEncoding[, length]])

• object <Объект> Объект, поддерживающий Symbol.toPrimitive или valueOf()
• offsetOrEncoding <число> | <строка> Смещение байта или кодировка, в зависимости от значения, возвращаемого object.valueOf() или object[Symbol.toPrimitive]().
• length <число> Длина, в зависимости от значения, возвращаемого object.valueOf() или object[Symbol.toPrimitive]().

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

Например:

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

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

Например:

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

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

Метод класса: Buffer.isBuffer(obj)

• obj <Объект>
• Возвращает: <булево>

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

Метод класса: Buffer.isEncoding(encoding)

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

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

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

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

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

buf[index]

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

Этот оператор унаследован от Uint8Array, поэтому его поведение при доступе за пределы допустимого диапазона такое же, как и у UInt8Array - при получении возвращается undefined, а при установке ничего не происходит.

Пример: Скопируйте строку ASCII в Buffer, по одному байту за раз

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

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

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

buf.buffer

Свойство buffer ссылается на базовый объект ArrayBuffer, на основе которого создан этот объект Buffer.

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

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

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

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

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

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

Примеры:

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

// Prints: 0
console.log(buf1.compare(buf1));

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

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

Примеры:

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

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

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

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

Будет выброшено исключение RangeError если: targetStart < 0, sourceStart < 0, targetEnd > target.byteLength или sourceEnd > source.byteLength.

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

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

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

Пример: Создайте два объекта Buffer, buf1 и buf2, и скопируйте buf1 с байта 16 по байт 19 в buf2, начиная с 8-го байта в buf2

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

buf1.copy(buf2, 8, 16, 20);

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

Пример: Создайте один объект Buffer и скопируйте данные из одной области в перекрывающуюся область внутри того же объекта 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);

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

buf.entries()

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

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

Пример: Выведите всё содержимое объекта Buffer

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

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

buf.equals(otherBuffer)

• otherBuffer <Buffer> Buffer или Uint8Array для сравнения.
• Возвращает: <булево>

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

Примеры:

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

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

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

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

• value <строка> | <Буфер> | <целое число> Значение, которым нужно заполнить buf.
• offset <целое число> Количество байтов, которые нужно пропустить перед началом заполнения buf. По умолчанию: 0.
• end <целое число> Где остановить заполнение buf (не включая). По умолчанию: buf.length.
• encoding <строка> Если value является строкой, это её кодировка. По умолчанию: 'utf8'.
• Возвращает: <Буфер> Ссылка на buf.

Заполняет buf заданным value. Если offset и end не указаны, весь buf будет заполнен. Это предназначено для небольшого упрощения создания и заполнения Buffer в одной строке.

Пример: Заполнение Buffer символом ASCII 'h'

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

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

value приводится к значению типа uint32, если это не строка или целое число.

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

Пример: Заполнение Buffer двухбайтовым символом

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

Если value содержит недопустимые символы, то оно усекается.

Если не осталось действительных данных для заполнения, буфер либо заполняется нулями, либо заполнение не выполняется, в зависимости от типа входных данных. Это поведение продиктовано причинами совместимости и было изменено на выброс исключения в Node.js v10, поэтому не рекомендуется полагаться на него.

const buf = Buffer.allocUnsafe(5);
// Prints: <Buffer 61 61 61 61 61>
console.log(buf.fill('a'));
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('aazz', 'hex'));
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'));

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

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

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

Примеры:

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

// Prints: true
console.log(buf.includes('this'));

// Prints: true
console.log(buf.includes('is'));

// Prints: true
console.log(buf.includes(Buffer.from('a buffer')));

// Prints: true
// (97 is the decimal ASCII value for 'a')
console.log(buf.includes(97));

// Prints: false
console.log(buf.includes(Buffer.from('a buffer example')));

// Prints: true
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));

// Prints: false
console.log(buf.includes('this', 4));

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

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

Если value:

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

Примеры:

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

// Prints: 0
console.log(buf.indexOf('this'));

// Prints: 2
console.log(buf.indexOf('is'));

// Prints: 8
console.log(buf.indexOf(Buffer.from('a buffer')));

// Prints: 8
// (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(97));

// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example')));

// Prints: 8
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

Примеры:

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

// Prints: 0
console.log(buf.lastIndexOf('this'));

// Prints: 17
console.log(buf.lastIndexOf('buffer'));

// Prints: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')));

// Prints: 15
// (97 is the decimal ASCII value for 'a')
console.log(buf.lastIndexOf(97));

// Prints: -1
console.log(buf.lastIndexOf(Buffer.from('yolo')));

// Prints: 5
console.log(buf.lastIndexOf('buffer', 5));

// Prints: -1
console.log(buf.lastIndexOf('buffer', 4));

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

// Prints: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'ucs2'));

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

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

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

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

• <целое>

Возвращает объем памяти, выделенной для buf в байтах. Обратите внимание, что это не обязательно отражает количество «используемых» данных в buf.

Пример: Создайте Buffer и запишите в него более короткую строку ASCII.

const buf = Buffer.alloc(1234);

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

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

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

Хотя свойство length не является неизменяемым, изменение значения length может привести к неопределённому и несогласованному поведению. Приложения, которые хотят изменить длину Buffer должны поэтому рассматривать length как только для чтения и использовать buf.slice() для создания нового Buffer.

Примеры:

let buf = Buffer.allocUnsafe(10);

buf.write('abcdefghj', 0, 'ascii');

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

buf = buf.slice(0, 5);

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

buf.parent

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

buf.readDoubleBE(offset[, noAssert])

buf.readDoubleLE(offset[, noAssert])

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

Читает 64-битное число с плавающей точкой из buf по указанному offset с указанным форматом порядка байтов (readDoubleBE() возвращает порядок байтов Big Endian, readDoubleLE() возвращает Little Endian).

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

Примеры:

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

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

// Prints: 5.447603722011605e-270
console.log(buf.readDoubleLE());

// Throws an exception: RangeError: Index out of range
console.log(buf.readDoubleLE(1));

// Warning: reads passed end of buffer!
// This will result in a segmentation fault! Don't do this!
console.log(buf.readDoubleLE(1, true));

buf.readFloatBE(offset[, noAssert])

buf.readFloatLE(offset[, noAssert])

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

Читает 32-битное число с плавающей точкой из buf по указанному offset с указанным форматом порядка байтов (readFloatBE() возвращает порядок байтов Big Endian, readFloatLE() возвращает Little Endian).

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

Примеры:

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

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

// Prints: 1.539989614439558e-36
console.log(buf.readFloatLE());

// Throws an exception: RangeError: Index out of range
console.log(buf.readFloatLE(1));

// Warning: reads passed end of buffer!
// This will result in a segmentation fault! Don't do this!
console.log(buf.readFloatLE(1, true));

buf.readInt8(offset[, noAssert])

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

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

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

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

Примеры:

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

// Prints: -1
console.log(buf.readInt8(0));

// Prints: 5
console.log(buf.readInt8(1));

// Throws an exception: RangeError: Index out of range
console.log(buf.readInt8(2));

buf.readInt16BE(offset[, noAssert])

buf.readInt16LE(offset[, noAssert])

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

Читает целое число со знаком 16 бит из buf по указанному offset с указанным форматом порядка байтов (readInt16BE() возвращает порядок байтов Big Endian, readInt16LE() возвращает Little Endian).

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

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

Примеры:

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

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

// Prints: 1280
console.log(buf.readInt16LE());

// Throws an exception: RangeError: Index out of range
console.log(buf.readInt16LE(1));

buf.readInt32BE(offset[, noAssert])

buf.readInt32LE(offset[, noAssert])

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

Читает целое число со знаком 32 бит из buf по указанному offset с указанным форматом порядка байтов (readInt32BE() возвращает порядок байтов Big Endian, readInt32LE() возвращает Little Endian).

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

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

Примеры:

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

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

// Prints: 83886080
console.log(buf.readInt32LE());

// Throws an exception: RangeError: Index out of range
console.log(buf.readInt32LE(1));

buf.readIntBE(offset, byteLength[, noAssert])

buf.readIntLE(offset, byteLength[, noAssert])

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

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

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

Примеры:

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

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

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

// Throws an exception: RangeError: Index out of range
console.log(buf.readIntBE(1, 6).toString(16));

buf.readUInt8(offset[, noAssert])

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

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

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

Примеры:

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

// Prints: 1
console.log(buf.readUInt8(0));

// Prints: 254
console.log(buf.readUInt8(1));

// Throws an exception: RangeError: Index out of range
console.log(buf.readUInt8(2));

buf.readUInt16BE(offset[, noAssert])

buf.readUInt16LE(offset[, noAssert])

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

Читает целое беззнаковое 16-битное число из buf по указанному offset с указанным форматом порядка байтов (readUInt16BE() возвращает порядок байтов big endian, readUInt16LE() возвращает little endian).

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

Примеры:

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

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

// Prints: 3412
console.log(buf.readUInt16LE(0).toString(16));

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

// Prints: 5634
console.log(buf.readUInt16LE(1).toString(16));

// Throws an exception: RangeError: Index out of range
console.log(buf.readUInt16LE(2).toString(16));

buf.readUInt32BE(offset[, noAssert])

buf.readUInt32LE(offset[, noAssert])

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

Читает целое беззнаковое 32-битное число из buf по указанному offset с указанным форматом порядка байтов (readUInt32BE() возвращает big endian, readUInt32LE() возвращает little endian).

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

Примеры:

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

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

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

// Throws an exception: RangeError: Index out of range
console.log(buf.readUInt32LE(1).toString(16));

buf.readUIntBE(offset, byteLength[, noAssert])

buf.readUIntLE(offset, byteLength[, noAssert])

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

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

Установка noAssert в true позволяет offset быть за пределами конца buf, но поведение в этом случае не определено.

Примеры:

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

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

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

// Throws an exception: RangeError: Index out of range
console.log(buf.readUIntBE(1, 6).toString(16));

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

• start <integer> С какой позиции начнется новый Buffer. По умолчанию: 0.
• end <integer> До какой позиции (не включая) будет продолжаться новый Buffer. По умолчанию: buf.length.
• Returns: <Buffer>

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

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

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

Пример: создание Buffer с латинским алфавитом, взятие среза и изменение одного байта в исходном 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.slice(0, 3);

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

buf1[0] = 33;

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

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

Примеры:

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

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

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

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

buf.swap16()

• Returns: <Buffer> Ссылка на buf.

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

Примеры:

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

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

buf1.swap16();

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

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

// Throws an exception: RangeError: Buffer size must be a multiple of 16-bits
buf2.swap16();

buf.swap32()

• Returns: <Buffer> Ссылка на buf.

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

Примеры:

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

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

buf1.swap32();

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

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

// Throws an exception: RangeError: Buffer size must be a multiple of 32-bits
buf2.swap32();

buf.swap64()

• Returns: <Buffer> Ссылка на buf.

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

Примеры:

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

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

buf1.swap64();

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

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

// Throws an exception: RangeError: Buffer size must be a multiple of 64-bits
buf2.swap64();

Обратите внимание, что JavaScript не может кодировать 64-битные целые числа. Этот метод предназначен для работы с 64-битными числами с плавающей точкой.

buf.toJSON()

• Returns: <Object>

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

Пример:

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

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

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

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

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

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

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

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

Примеры:

const buf1 = Buffer.allocUnsafe(26);

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

// Prints: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('ascii'));

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

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

// Prints: 74c3a97374
console.log(buf2.toString('hex'));

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

// Prints: té
console.log(buf2.toString(undefined, 0, 3));

buf.values()

• Returns: <Iterator>

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

Примеры:

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

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

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

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

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

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

Пример:

const buf = Buffer.allocUnsafe(256);

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

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

buf.writeDoubleBE(value, offset[, noAssert])

buf.writeDoubleLE(value, offset[, noAssert])

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

Записывает value в buf по указанной offset позиции со специфицированным форматом порядка байтов (writeDoubleBE() записывает в формате big endian, writeDoubleLE() записывает в формате little endian). value должен быть действительным 64-битным double. Поведение не определено, когда value не является 64-битным double.

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

Примеры:

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleBE(0xdeadbeefcafebabe, 0);

// Prints: <Buffer 43 eb d5 b7 dd f9 5f d7>
console.log(buf);

buf.writeDoubleLE(0xdeadbeefcafebabe, 0);

// Prints: <Buffer d7 5f f9 dd b7 d5 eb 43>
console.log(buf);

buf.writeFloatBE(value, offset[, noAssert])

buf.writeFloatLE(value, offset[, noAssert])

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

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

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

Примеры:

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

buf.writeFloatLE(0xcafebabe, 0);

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

buf.writeInt8(value, offset[, noAssert])

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

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

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

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

Примеры:

const buf = Buffer.allocUnsafe(2);

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

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

buf.writeInt16BE(value, offset[, noAssert])

buf.writeInt16LE(value, offset[, noAssert])

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

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

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

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

Примеры:

const buf = Buffer.allocUnsafe(4);

buf.writeInt16BE(0x0102, 0);
buf.writeInt16LE(0x0304, 2);

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

buf.writeInt32BE(value, offset[, noAssert])

buf.writeInt32LE(value, offset[, noAssert])

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

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

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

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

Примеры:

const buf = Buffer.allocUnsafe(8);

buf.writeInt32BE(0x01020304, 0);
buf.writeInt32LE(0x05060708, 4);

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

buf.writeIntBE(value, offset, byteLength[, noAssert])

buf.writeIntLE(value, offset, byteLength[, noAssert])

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

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

Установка noAssert в true позволяет закодированной форме value выходить за пределы buf, но поведение в этом случае не определено.

Примеры:

const buf = Buffer.allocUnsafe(6);

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

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

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

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

buf.writeUInt8(value, offset[, noAssert])

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

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

Установка noAssert в true позволяет закодированной форме value выходить за пределы buf, но поведение в этом случае не определено.

Примеры:

const buf = Buffer.allocUnsafe(4);

buf.writeUInt8(0x3, 0);
buf.writeUInt8(0x4, 1);
buf.writeUInt8(0x23, 2);
buf.writeUInt8(0x42, 3);

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

buf.writeUInt16BE(value, offset[, noAssert])

buf.writeUInt16LE(value, offset[, noAssert])

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

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

Установка noAssert в true позволяет закодированной форме value выходить за пределы buf, но поведение в этом случае не определено.

Примеры:

const buf = Buffer.allocUnsafe(4);

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

// Prints: <Buffer de ad be ef>
console.log(buf);

buf.writeUInt16LE(0xdead, 0);
buf.writeUInt16LE(0xbeef, 2);

// Prints: <Buffer ad de ef be>
console.log(buf);

buf.writeUInt32BE(value, offset[, noAssert])

buf.writeUInt32LE(value, offset[, noAssert])

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

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

Установка noAssert в true позволяет закодированной форме value выходить за пределы buf, но поведение в этом случае не определено.

Примеры:

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

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

buf.writeUInt32LE(0xfeedface, 0);

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

buf.writeUIntBE(value, offset, byteLength[, noAssert])

buf.writeUIntLE(value, offset, byteLength[, noAssert])

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

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

Установка noAssert в true позволяет закодированной форме value выходить за пределы buf, но поведение в этом случае не определено.

Примеры:

const buf = Buffer.allocUnsafe(6);

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

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

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

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

buffer.INSPECT_MAX_BYTES

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

Возвращает максимальное количество байтов, которое будет возвращено при вызове buf.inspect(). Этот параметр может быть переопределён пользовательскими модулями. См. util.inspect() для получения дополнительных сведений о поведении buf.inspect().

Обратите внимание, что это свойство модуля buffer, возвращённого require('buffer'), а не глобальной переменной Buffer или экземпляра Buffer.

buffer.kMaxLength

• <integer> Максимальный размер, разрешённый для одного экземпляра Buffer.

Псевдоним для buffer.constants.MAX_LENGTH

Обратите внимание, что это свойство модуля buffer, возвращённого require('buffer'), а не глобальной переменной Buffer или экземпляра Buffer.

buffer.transcode(source, fromEnc, toEnc)

• source <Буфер> | <Uint8Array> Экземпляр Buffer или Uint8Array.
• fromEnc <строка> Текущее кодирование.
• toEnc <строка> Кодирование для перекодирования.

Перекодирует заданный экземпляр Buffer или Uint8Array из одного кодирования символов в другое. Возвращает новый экземпляр Buffer.

Выбрасывает исключение, если fromEnc или toEnc указывают недопустимое кодирование символов или если преобразование из fromEnc в toEnc запрещено.

Процесс транскодирования будет использовать символы подстановки, если заданная последовательность байтов не может быть адекватно представлена в целевом кодировании. Например:

const buffer = require('buffer');

const newBuf = buffer.transcode(Buffer.from('€'), 'utf8', 'ascii');
console.log(newBuf.toString('ascii'));
// Prints: '?'

Так как знак евро (€) не может быть представлен в US-ASCII, он заменяется на ? в транскодированном Buffer.

Обратите внимание, что это свойство модуля buffer возвращаемого require('buffer'), а не глобальной переменной Buffer или экземпляра Buffer.

Класс: SlowBuffer

Возвращает не-пуллированный Buffer.

Для предотвращения накладных расходов на сборку мусора при создании многих индивидуально выделенных экземпляров Buffer, по умолчанию выделения меньше 4 КБ берутся из одного большего выделенного объекта.

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

Пример:

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

socket.on('readable', () => {
  const data = socket.read();

  // Allocate for retained data
  const sb = SlowBuffer(10);

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

  store.push(sb);
});

Использование SlowBuffer должно использоваться только в крайних случаях, после того, как разработчик наблюдал ненадлежащее удержание памяти в своих приложениях.

new SlowBuffer(size)

• size <целое> Требуемая длина нового SlowBuffer.

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

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

Пример:

const { SlowBuffer } = require('buffer');

const buf = new SlowBuffer(5);

// Prints: (contents may vary): <Buffer 78 e0 82 02 01>
console.log(buf);

buf.fill(0);

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

Константы буфера

Обратите внимание, что buffer.constants — свойство модуля buffer возвращаемого require('buffer'), а не глобальной переменной Buffer или экземпляра Buffer.

buffer.constants.MAX_LENGTH

• <целое> Максимальный размер, разрешённый для одного экземпляра Buffer.

На 32-битных архитектурах это значение равно (2^30)-1 (~1 ГБ). На 64-битных архитектурах это значение равно (2^31)-1 (~2 ГБ).

Это значение также доступно как buffer.kMaxLength.

buffer.constants.MAX_STRING_LENGTH

• <целое> Максимальная длина разрешённая для одного экземпляра string.

Представляет максимальную length которую может иметь примитив string, подсчитанную в единицах кода UTF-16.

Это значение может зависеть от используемого движка JS.