Буфер

Устойчивость: 2 - Стабильно

Перед введением TypedArray в ECMAScript 2015 (ES6), язык JavaScript не имел механизма для чтения или обработки потоков двоичных данных. Класс Buffer был введён как часть API Node.js, чтобы обеспечить взаимодействие с потоками октетов в контексте таких операций, как TCP-потоки и файловые операции.

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

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

Класс Buffer является глобальным в Node.js, поэтому вряд ли потребуется использовать 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 указанного размера. Память, выделенная для таких экземпляров Buffer, не инициализируется и может содержать конфиденциальные данные. Такие экземпляры Buffer необходимо инициализировать ручно, используя либо buf.fill(0), либо записывая в Buffer полностью. Хотя такое поведение намеренное и улучшает производительность, опыт разработки показал, что требуется более чёткое различие между созданием быстрого, но неинициализированного буфера Buffer и созданием медленного, но безопасного буфера 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` командной строки

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

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 и имён файлов алфавит", как указано в 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 в ECMAScript 2015. Например, в то время как ArrayBuffer#slice() создаёт копию среза, реализация Buffer#slice() создаёт представление над существующим Buffer без копирования, что делает Buffer#slice() значительно эффективнее.

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

Память объекта Buffer копируется в TypedArray, а не разделяются.
Память объекта Buffer интерпретируется как массив отдельных элементов, а не как массив байтов целевого типа. То есть, new Uint32Array(Buffer.from([1, 2, 3, 4])) создаёт 4-элементный Uint32Array с элементами [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])

Буферы и итерирование ES6

Экземпляры Buffer могут быть итерированы с помощью ECMAScript 2015 (ES6) синтаксиса 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)

Устарело начиная с версии: v6.0.0

Уровень стабильности: 0 - Устарело: Используйте Buffer.from(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(buffer)

Устарело начиная с версии: v6.0.0

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

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

Копирует переданные 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(arrayBuffer[, byteOffset [, length]])

Устарело начиная с версии: v6.0.0

Уровень стабильности: 0 - Устарело: Используйте Buffer.from(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(size)

Устарело начиная с версии: v6.0.0

Уровень стабильности: 0 - Устарело: Используйте Buffer.alloc() вместо этого (также см. Buffer.allocUnsafe()).

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

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

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

Пример:

const buf = new Buffer(10);

// Prints: (contents may vary): <Buffer 48 21 4b 00 00 00 00 00 30 dd>
console.log(buf);

buf.fill(0);

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

new Buffer(string[, encoding])

Устарело начиная с версии: v6.0.0

Уровень стабильности: 0 - Устарело: Используйте Buffer.from(string[, encoding]) вместо этого.

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

Создаёт новый Buffer, содержащий указанную JavaScript строку 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]])

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

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

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

Пример:

const buf = Buffer.alloc(5);

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

Значение size должно быть меньше или равно значению buffer.kMaxLength. В противном случае будет выброшено исключение RangeError. Буфер нулевой длины будет создан, если size <= 0.

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

Пример:

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

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

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

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

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

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

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

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

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

Пример:

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 экземпляр размером 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)

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

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

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

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

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

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

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

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

В противном случае, конвертирует в String и возвращает длину в байтах строки.

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

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

buf1 <Buffer>
buf2 <Buffer>
Возвращает: <integer>

Сравнивает 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])

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

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

Возвращает новый 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)

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

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

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

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)

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

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

Копирует переданные данные 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])

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

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

Создаёт новый Buffer, содержащий переданную строку JavaScript 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.isBuffer(obj)

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

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

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

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

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

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

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

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

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

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

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

buf[index]

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

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

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

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.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])

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

target <Буфер> Buffer для сравнения.
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]]])

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

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

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

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

Создаёт и возвращает итератор пар [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)

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

otherBuffer <Buffer> Объект Buffer для сравнения.
Возвращает: <boolean>

Возвращает 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])

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

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

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

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

value <строка> | <Buffer> | <целое> Что искать.
byteOffset <целое> С какого байта начать поиск в buf. По умолчанию: 0
encoding <строка> Если value является строкой, это её кодировка. По умолчанию: 'utf8'
Возвращает: <boolean> 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])

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

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

Если value:

является строкой, value интерпретируется в соответствии с кодировкой символов в encoding.
является Buffer, 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', []));

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

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

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

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

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

Создаёт и возвращает итератор по ключам (индексам) 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])

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

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

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

Примеры:

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', []));

buf.length

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

<целое>

Возвращает количество памяти, выделенной для 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.readDoubleBE(offset[, noAssert])

buf.readDoubleLE(offset[, noAssert])

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

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

Читает 64-битное double из 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])

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

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

Читает 32-битное float из 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])

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

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

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

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

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

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

Added in: v0.11.15

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

Added in: v0.5.0

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

Added in: v0.5.5

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

Считывает целое без знака 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])

Added in: v0.5.5

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

Считывает целое без знака 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])

Added in: v0.11.15

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

Added in: v0.3.0

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

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

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

Пример: Создать Buffer с ASCII алфавитом, взять срез и затем изменить один байт из исходного 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()

Added in: v5.10.0

Возвращает: <Буфер> Ссылка на 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()

Added in: v5.10.0

Возвращает: <Буфер> Ссылка на 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()

Added in: v6.3.0

Возвращает: <Буфер> Ссылка на 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.toString([encoding[, start[, end]]])

Added in: v0.1.90

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

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

Примеры:

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

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

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

Возвращает представление объекта buf в формате JSON. 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.values()

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

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

Создаёт и возвращает итератор для значений 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])

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

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

Записывает 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])

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

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

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

Установка 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])

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

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

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

Примеры:

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

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

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

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

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

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

value <целое> Число, которое будет записано в buf.
offset <целое> Смещение байта для начала записи. Должно удовлетворять условию: 0 <= offset <= buf.length - 2.
noAssert <логическое> Пропустить проверку value и offset? По умолчанию: false
Возвращает: <целое> 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);

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

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

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

Added in: v0.5.5

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

Added in: v0.11.15

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

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

Примеры:

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

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

Added in: v0.5.0

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

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

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

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

Added in: v0.5.5

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

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

Added in: v0.5.5

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

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

Примеры:

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

Added in: v0.5.5

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

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

Примеры:

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

buffer.INSPECT_MAX_BYTES

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

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

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

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

buffer.kMaxLength

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

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

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

Класс: SlowBuffer

Устарел начиная с: v6.0.0

Уровень стабильности: 0 - Устарел: Используйте Buffer.allocUnsafeSlow() вместо этого.

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

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

В случае, если разработчик может нуждаться в удержании небольшого блока памяти из пула в течение неопределенного времени, может быть целесообразно создать экземпляр непуллированного 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)

Устарел начиная с: v6.0.0

Уровень стабильности: 0 - Устарел: Используйте Buffer.allocUnsafeSlow() вместо этого.

size <целое> Желаемая длина нового SlowBuffer.

Выделяет новый SlowBuffer размером в size байт. size должен быть меньше или равен значению buffer.kMaxLength. В противном случае будет выброшено исключение RangeError. Будет создан Buffer нулевой длины, если size <= 0.

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

Пример:

const SlowBuffer = require('buffer').SlowBuffer;

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

© Joyent, Inc. and other Node contributors
Licensed under the MIT License.
Node.js is a trademark of Joyent, Inc. and is used with its permission.
We are not endorsed by or affiliated with Joyent.
https://nodejs.org/dist/latest-v6.x/docs/api/buffer.html

Буфер

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

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

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

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

Буферы и TypedArray

Буферы и итерирование ES6

Класс: Buffer

new Buffer(array)

new Buffer(buffer)

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

new Buffer(size)

new Buffer(string[, encoding])

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

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

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

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

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

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

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

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

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

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

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

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

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

buf[index]

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

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

buf.entries()

buf.equals(otherBuffer)

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

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

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

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

buf.keys()

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

buf.length

buf.readDoubleBE(offset[, noAssert])

buf.readDoubleLE(offset[, noAssert])

buf.readFloatBE(offset[, noAssert])

buf.readFloatLE(offset[, noAssert])

buf.readInt8(offset[, noAssert])

buf.readInt16BE(offset[, noAssert])

buf.readInt16LE(offset[, noAssert])

buf.readInt32BE(offset[, noAssert])

buf.readInt32LE(offset[, noAssert])

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

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

buf.readUInt8(offset[, noAssert])

buf.readUInt16BE(offset[, noAssert])

buf.readUInt16LE(offset[, noAssert])

buf.readUInt32BE(offset[, noAssert])

buf.readUInt32LE(offset[, noAssert])

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

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

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

buf.swap16()

buf.swap32()

buf.swap64()

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

buf.toJSON()

buf.values()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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