Буфер

До появления 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 до 6.0.0, экземпляры 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() отличается в зависимости от типа первого аргумента, в приложениях могут случайно возникать проблемы с безопасностью и надёжностью, если не выполняется проверка аргументов или инициализация 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. Поскольку Buffer не инициализирован, выделенный кусок памяти может содержать устаревшие потенциально чувствительные данные.

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

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

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

console.log(Buffer.from('fhqwhgads', 'ascii'));
// 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 кодировки символов:

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

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

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

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

• 'base64' - Кодировка Base64. При создании Buffer из строки эта кодировка также корректно примет "безопасный для URL и имён файлов алфавит", как указано в RFC4648, Раздел 5.

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

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

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

Современные веб-браузеры следуют стандарту кодирования WHATWG, который делает псевдонимами 'latin1' и 'ISO-8859-1' к 'win-1252'. Это означает, что выполняя что-то вроде http.get(), если возвращённый набор символов находится в списке, указанном в спецификации 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])) создаёт 4-элементный Uint32Array с элементами [1, 2, 3, 4], а не Uint32Array с одним элементом [0x1020304] или [0x4030201].

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

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 могут итерироваться с помощью синтаксиса 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);

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>

new Buffer(buffer)

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

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

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

buf1[0] = 0x61;

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

new Buffer(size)

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

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

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

const buf = new Buffer(10);

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

new Buffer(string[, encoding])

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

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

const buf1 = new Buffer('this is a tést');
const buf2 = new Buffer('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('ascii'));
// Prints: this is a tC)st

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

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

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

const buf = Buffer.alloc(5);

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

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

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

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

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

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

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 никогда не будет содержать конфиденциальных данных.

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

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

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

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

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

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

Обратите внимание, что модуль Buffer предварительно выделяет внутренний экземпляр Buffer размером Buffer.poolSize, который используется как пул для быстрого выделения новых экземпляров Buffer созданных с помощью Buffer.allocUnsafe() и устаревшего конструктора new Buffer(size) только когда 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)[src]

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

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

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

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

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

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

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

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

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

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

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

Для 'base64' и 'hex', эта функция предполагает корректный ввод. Для строк, содержащих данные, не закодированные в Base64/Hex (например, пробелы), возвращаемое значение может быть больше длины 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, возвращается фактическая длина в байтах.

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

• buf1 <Буфер> | <Uint8Array>
• buf2 <Буфер> | <Uint8Array>
• Возвращает: <целое число>

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

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

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

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

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

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

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

// 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.from(array)[src]

• 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]])[src]

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

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.

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

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

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

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

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

Копирует переданные данные буфера buffer в новый экземпляр буфера 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

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

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

• 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'));
// Prints: <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');
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>

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

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

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

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('ascii'));
// Prints: this is a tC)st

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

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

• obj <Объект>
• Возвращает: <логическое значение>

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

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

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

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

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

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

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

buf[index]

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

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

// Copy an ASCII string into a `Buffer` one byte at a time.

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('ascii'));
// Prints: Node.js

buf.buffer

• <ArrayBuffer> Основной объект ArrayBuffer на основе которого создан этот объект Buffer.

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

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

buf.byteOffset

• <целое число> byteOffset основного объекта ArrayBuffer, на основе которого создан этот объект Buffer.

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

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

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

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

// When casting the Node.js Buffer to an Int8 TypedArray remember to use the
// byteOffset.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);

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

• target <Buffer> | <Uint8Array> Buffer или Uint8Array, с которыми необходимо сравнить buf.
• 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');

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 соответственно.

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

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

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

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

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

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

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

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

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

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

// 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)[src]

• otherBuffer <Буфер> Buffer или Uint8Array для сравнения с buf.
• Возвращает: <логическое>

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

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

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

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

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

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

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

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

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

// Fill a `Buffer` with a two-byte character.

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

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

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[, byteOffset][, encoding])[src]

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

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

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[, byteOffset][, encoding])[src]

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

Если value:

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

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 не является строкой, числом или буфером, этот метод выбросит TypeError. Если value является числом, оно будет преобразовано в допустимое значение байта, целое число от 0 до 255.

Если byteOffset не является числом, оно будет приведено к числу. Если результат приведения к числу — NaN или 0, весь буфер будет просмотрен. Это поведение соответствует 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');

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

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

• value <строка> | <Буфер> | <Uint8Array> | <целое число> Что искать.
• 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');

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

// Create a `Buffer` and write a shorter ASCII string to it.

const buf = Buffer.alloc(1234);

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

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

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

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

let buf = Buffer.allocUnsafe(10);

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

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

buf = buf.slice(0, 5);

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

buf.parent

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

buf.readBigInt64BE(offset)

buf.readBigInt64LE(offset)

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

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

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

buf.readBigUInt64BE(offset)

buf.readBigUInt64LE(offset)

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

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

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

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

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

buf.readDoubleBE(offset)

buf.readDoubleLE(offset)

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

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

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

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

buf.readFloatBE(offset)

buf.readFloatLE(offset)

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

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

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

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

buf.readInt8(offset)

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

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

Целые числа, считанные из 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)

buf.readInt16LE(offset)

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

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

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

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

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

buf.readInt32BE(offset)

buf.readInt32LE(offset)

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

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

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

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

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

buf.readIntBE(offset, byteLength)

buf.readIntLE(offset, byteLength)

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

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

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

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

buf.readUInt8(offset)

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

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

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)

buf.readUInt16LE(offset)

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

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

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

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

buf.readUInt32BE(offset)

buf.readUInt32LE(offset)

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

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

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

console.log(buf.readUInt32BE(0).toString(16));
// Prints: 12345678
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)

buf.readUIntLE(offset, byteLength)

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

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

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

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

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

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

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

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

Изменение среза нового Buffer изменит память в оригинальном 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.slice(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 , а не начала.

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

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

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

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

buf.swap16()[src]

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

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

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 little-endian и UTF-16 big-endian:

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

buf.swap32()[src]

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

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

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()[src]

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

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

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

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

buf.toJSON()[src]

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

Возвращает JSON-представление buf. JSON.stringify() неявно вызывает эту функцию при сериализации экземпляра 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.data) :
    value;
});

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

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

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

Декодирует 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;
}

console.log(buf1.toString('ascii'));
// Prints: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('ascii', 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()

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

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

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

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

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

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: ½ + ¼ = ¾

buf.writeBigInt64BE(value, offset)

buf.writeBigInt64LE(value, offset)

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

Записывает value в buf по указанному offset с указанным форматом порядка байтов (writeBigInt64BE() записывает в формате big-endian, writeBigInt64LE() записывает в формате little-endian).

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

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64BE(0x0102030405060708n, 0);

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

buf.writeBigUInt64BE(value, offset)

buf.writeBigUInt64LE(value, offset)

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

Записывает value в buf по указанному offset с указанным форматом порядка байтов (writeBigUInt64BE() записывает в формате big-endian, writeBigUInt64LE() записывает в формате little-endian).

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64LE(0xdecafafecacefaden, 0);

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

buf.writeDoubleBE(value, offset)

buf.writeDoubleLE(value, offset)

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

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

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(123.456, 0);

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

buf.writeFloatBE(value, offset)

buf.writeFloatLE(value, offset)

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

buf.writeFloatLE(0xcafebabe, 0);

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

buf.writeInt8(value, offset)

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

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

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

const buf = Buffer.allocUnsafe(2);

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

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

buf.writeInt16BE(value, offset)

buf.writeInt16LE(value, offset)

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

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

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

const buf = Buffer.allocUnsafe(4);

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

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

buf.writeInt32BE(value, offset)

buf.writeInt32LE(value, offset)

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

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

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

const buf = Buffer.allocUnsafe(8);

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

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

buf.writeIntBE(value, offset, byteLength)

buf.writeIntLE(value, offset, byteLength)

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

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

const buf = Buffer.allocUnsafe(6);

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

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

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

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

buf.writeUInt8(value, offset)

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

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

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)

buf.writeUInt16LE(value, offset)

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

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

const buf = Buffer.allocUnsafe(4);

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

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

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

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

buf.writeUInt32BE(value, offset)

buf.writeUInt32LE(value, offset)

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

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

buf.writeUInt32LE(0xfeedface, 0);

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

buf.writeUIntBE(value, offset, byteLength)

buf.writeUIntLE(value, offset, byteLength)

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

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

const buf = Buffer.allocUnsafe(6);

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

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

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

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

buffer.INSPECT_MAX_BYTES

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

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

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

buffer.kMaxLength

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

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

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

buffer.transcode(source, fromEnc, toEnc)

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

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

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

Кодирования, поддерживаемые buffer.transcode(): 'ascii', 'utf8', 'utf16le', 'ucs2', 'latin1' и 'binary'.

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

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', () => {
  let data;
  while (null !== (data = readable.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, выбрасывается ERR_INVALID_OPT_VALUE. Создаётся Buffer длиной 0, если size равно 0.

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

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

const buf = new SlowBuffer(5);

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

buf.fill(0);

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

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

Обратите внимание, что 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.