Buffer — Node.js 14 LTS

Буфер

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

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

Класс Buffer является подклассом класса JavaScript Uint8Array и расширяет его методами, которые охватывают дополнительные случаи использования. API Node.js принимают обычные Uint8Array там, где поддерживаются 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 bytes which all have the value `1`.
const buf2 = Buffer.alloc(10, 1);

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

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

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

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

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

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

История

Версия	Изменения
v6.4.0	Введен `latin1` в качестве псевдонима для `binary`.
v5.0.0	Устранены устаревшие кодировки `raw` и `raws`.

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

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

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

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

Кодировки символов, в настоящее время поддерживаемые Node.js:

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

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

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

'base64': Кодировка Base64. При создании Buffer из строки эта кодировка также корректно примет «Алфавит URL и безопасных имен файлов», как указано в RFC 4648, Раздел 5. Пробельные символы, такие как пробелы, табуляции и новые строки, содержащиеся в base64-строке, игнорируются.
'hex': Кодировка каждого байта в два шестнадцатеричных символа. Может произойти усечение данных при декодировании строк, которые содержат исключительно допустимые шестнадцатеричные символы. См. пример ниже.

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

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

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

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

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

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

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

История

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

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

В частности:

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

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

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

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

console.log(uint32array);

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

Передача базового ArrayBuffer Buffer создаст TypedArray, который разделяет память с Buffer.

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

console.log(uint16array);

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

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

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 с помощью свойства 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]);

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

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

Класс: `Buffer`

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

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

История

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

size <целое число> Желаемая длина нового Buffer.
fill <строка> | <Buffer> | <Uint8Array> | <целое число> Значение для предварительного заполнения нового 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>

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

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

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

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

История

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

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

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

Базовая память для экземпляров 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(), Buffer.from(array), Buffer.concat() и устаревшего конструктора 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 <целое число> Желаемая длина нового Buffer.

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

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

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

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

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

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

История

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

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

Возвращает длину строки в байтах при кодировании с использованием encoding. Это не то же самое, что 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, возвращается длина в байтах, сообщённая .byteLength.

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

История

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

buf1 <Буфер> | <Uint8Массив>
buf2 <Буфер> | <Uint8Массив>
Возвращает: <целое число> Либо -1, либо 0, либо 1, в зависимости от результата сравнения. Подробности см. в buf.compare().

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

История

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

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

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

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

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

Если 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.concat() также может использовать внутренний пул Buffer аналогично тому, как это делает Buffer.allocUnsafe().

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

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

array <целое число[]>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

buffer <Буфер> | <Uint8Массив> Существующий 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().

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

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

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

Для объектов, чья функция 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]('string'), offsetOrEncoding).

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>

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

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

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

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('latin1'));
// Prints: this is a tÃ©st

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`buf[index]`

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

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

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

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

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

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

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

`buf.buffer`

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

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

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

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

`buf.byteOffset`

<целое число> Смещение byteOffset объекта Buffer базового объекта ArrayBuffer.

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

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

Типичная проблема при создании объекта TypedArray, который совмещает память с Buffer, заключается в том, что в этом случае необходимо правильно указать 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 Int8Array, use the byteOffset
// to refer only to the part of `nodeBuffer.buffer` that contains the memory
// for `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);

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

История

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

target <Буфер> | <Uint8Array> Буфер или 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_OUT_OF_RANGE выбрасывается, если targetStart < 0, sourceStart < 0, targetEnd > target.byteLength, или sourceEnd > source.byteLength.

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

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

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

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

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

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

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

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

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

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

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

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

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

История

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

otherBuffer <Buffer> | <Uint8Array> Массив Buffer или Uint8Array для сравнения с buf.
Возвращает: <boolean>

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

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

История

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

value <string> | <Buffer> | <Uint8Array> | <целое> Значение, которым нужно заполнить buf.
offset <целое> Количество байтов, которые нужно пропустить, прежде чем начать заполнение buf. По умолчанию: 0.
end <целое> До какой позиции (не включая) заполнять buf. По умолчанию: buf.length.
encoding <строка> Кодировка для value , если value является строкой. По умолчанию: 'utf8'.
Возвращает: <Buffer> Ссылка на 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 character that takes up two bytes in UTF-8.

console.log(Buffer.allocUnsafe(5).fill('\u0222'));
// Prints: <Buffer c8 a2 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])`

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

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

История

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

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

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

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

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

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

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

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

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

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

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

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

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

История

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

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

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

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

Если 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`

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

<integer>

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

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

const buf = Buffer.alloc(1234);

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

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

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

`buf.parent`

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

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

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

`buf.readBigInt64BE([offset])`

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

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

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

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

`buf.readBigInt64LE([offset])`

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

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

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

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

`buf.readBigUInt64BE([offset])`

История

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

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

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

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

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

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

`buf.readBigUInt64LE([offset])`

История

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

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

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

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

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

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

`buf.readDoubleBE([offset])`

История

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

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

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

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

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

`buf.readDoubleLE([offset])`

История

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

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

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

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

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

`buf.readFloatBE([offset])`

История

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

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

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

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

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

`buf.readFloatLE([offset])`

История

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

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

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

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

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

`buf.readInt8([offset])`

История

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

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

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

История

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

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

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

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

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

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

`buf.readInt16LE([offset])`

История

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

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

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

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

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

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

`buf.readInt32BE([offset])`

История

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

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

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

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

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

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

`buf.readInt32LE([offset])`

История

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

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

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

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

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

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

`buf.readIntBE(offset, byteLength)`

История

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

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

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

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

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

`buf.readIntLE(offset, byteLength)`

История

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

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

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

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

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

`buf.readUInt8([offset])`

История

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

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

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

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

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

История

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

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

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

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

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

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

`buf.readUInt16LE([offset])`

История

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

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

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

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

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

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

`buf.readUInt32BE([offset])`

История

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

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

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

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

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

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

`buf.readUInt32LE([offset])`

История

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

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

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

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

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

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

`buf.readUIntBE(offset, byteLength)`

История

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

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

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

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

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

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

`buf.readUIntLE(offset, byteLength)`

История

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

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

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

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

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

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

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

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

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

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

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

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

Изменение нового 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.subarray(0, 3);

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

buf1[0] = 33;

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

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

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

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

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

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

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

История

Версия	Изменения
v7.0.0	Все смещения теперь приводятся к целым числам перед любыми вычислениями с ними.
v7.1.0, v6.9.2	Приведение смещений к целым числам теперь корректно обрабатывает значения, выходящие за пределы 32-битного диапазона.
v0.3.0	Добавлена в: v0.3.0

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

Это тот же механизм, что и у buf.subarray().

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

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

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

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

`buf.swap16()`

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

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

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

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

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

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

`buf.toJSON()`

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

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

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

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

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

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

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

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

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

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

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

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

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

Максимальная длина экземпляра строки (в единицах кода 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('utf8'));
// Prints: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5));
// Prints: abcde

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

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

`buf.values()`

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

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

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

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

string <строка> Строка, которую нужно записать в buf.
offset <целое число> Количество байтов, которые нужно пропустить перед началом записи string. По умолчанию: 0.
length <целое число> Максимальное количество байтов для записи (записанные байты не превысят buf.length - offset). По умолчанию: 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: ½ + ¼ = ¾

const buffer = Buffer.alloc(10);

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

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

`buf.writeBigInt64BE(value[, offset])`

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

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

Записывает value в buf по указанному смещению offset в формате big-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.writeBigInt64LE(value[, offset])`

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

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

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64LE(0x0102030405060708n, 0);

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

`buf.writeBigUInt64BE(value[, offset])`

История

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

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

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64BE(0xdecafafecacefaden, 0);

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

`buf.writeBigUInt64LE(value[, offset])`

История

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

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64LE(0xdecafafecacefaden, 0);

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

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

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

История

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

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleBE(123.456, 0);

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

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

История

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

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

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

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleLE(123.456, 0);

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

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

История

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

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

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

История

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

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

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

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

История

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

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

История

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

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

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

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

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

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

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

История

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

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

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

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

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

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

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

История

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

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

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

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

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

История

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

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

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeInt32LE(0x05060708, 0);

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

`buf.writeIntBE(value, offset, byteLength)`

История

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

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

Записывает byteLength байтов value в buf по указанному offset в формате big-endian. Поддерживает точность до 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(value, offset, byteLength)`

История

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

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

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

const buf = Buffer.allocUnsafe(6);

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

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

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

История

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

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

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

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

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

История

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

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

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

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

const buf = Buffer.allocUnsafe(4);

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

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

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

История

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

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

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

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

const buf = Buffer.allocUnsafe(4);

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

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

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

История

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

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

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

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

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

История

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

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

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

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

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

`buf.writeUIntBE(value, offset, byteLength)`

История

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

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

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

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

const buf = Buffer.allocUnsafe(6);

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

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

`buf.writeUIntLE(value, offset, byteLength)`

История

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

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

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

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

const buf = Buffer.allocUnsafe(6);

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

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

`new Buffer(array)`

История

Версия	Изменения
v10.0.0	Вызов этого конструктора выводит предупреждение об устаревании, если он выполняется из кода вне каталога `node_modules`.
v7.2.1	Вызов этого конструктора больше не выводит предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь выводит предупреждение об устаревании.
v6.0.0	Устаревший с: v6.0.0

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

array <массив целых чисел> Массив байтов, из которого нужно выполнить копирование.

См. Buffer.from(array).

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

История

Версия	Изменения
v10.0.0	Вызов этого конструктора выводит предупреждение об устаревании, если он выполняется из кода вне каталога `node_modules`.
v7.2.1	Вызов этого конструктора больше не выводит предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь выводит предупреждение об устаревании.
v6.0.0	Теперь поддерживаются параметры `byteOffset` и `length`.
v6.0.0	Устаревший с: v6.0.0
v3.0.0	Добавлена в: v3.0.0

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

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

См. Buffer.from(arrayBuffer[, byteOffset[, length]]).

`new Buffer(buffer)`

История

Версия	Изменения
v10.0.0	Вызов этого конструктора выводит предупреждение об устаревании, если он выполняется из кода вне каталога `node_modules`.
v7.2.1	Вызов этого конструктора больше не выводит предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь выводит предупреждение об устаревании.
v6.0.0	Устаревший с: v6.0.0

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

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

См. Buffer.from(buffer).

`new Buffer(size)`

История

Версия	Изменения
v10.0.0	Вызов этого конструктора выводит предупреждение об устаревании, если он выполняется из кода вне каталога `node_modules`.
v8.0.0	`new Buffer(size)` по умолчанию вернёт заполненную нулями память.
v7.2.1	Вызов этого конструктора больше не выводит предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь выводит предупреждение об устаревании.
v6.0.0	Устаревший с: v6.0.0

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

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

См. Buffer.alloc() и Buffer.allocUnsafe(). Этот вариант конструктора эквивалентен Buffer.alloc().

`new Buffer(string[, encoding])`

История

Версия	Изменения
v10.0.0	Вызов этого конструктора генерирует предупреждение об устаревании, когда он выполняется вне каталога `node_modules`.
v7.2.1	Вызов этого конструктора больше не генерирует предупреждение об устаревании.
v7.0.0	Вызов этого конструктора теперь генерирует предупреждение об устаревании.
v6.0.0	Устарело начиная с версии: v6.0.0

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

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

См. Buffer.from(string[, encoding]).

`buffer` API модуля

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

`buffer.atob(data)`

Добавлена в: v14.17.0

data <любой> Кодированная в Base64 входная строка.

Декодирует строку Base64-кодированных данных в байты и кодирует эти байты в строку с использованием кодировки Latin-1 (ISO-8859-1).

Значение data может быть любым JavaScript-значением, которое можно привести к строке.

Эта функция предоставляется только для совместимости со старыми API веб-платформ и никогда не должна использоваться в новом коде, так как они используют строки для представления двоичных данных и предшествуют введению типизированных массивов в JavaScript. Для кода, работающего с API Node.js, преобразование между строками, закодированными в Base64, и двоичными данными должно выполняться с использованием Buffer.from(str, 'base64') и buf.toString('base64').

`buffer.btoa(data)`

Добавлена в: v14.17.0

data <любой> Строка ASCII (Latin1).

Декодирует строку в байты с использованием Latin-1 (ISO-8859) и кодирует эти байты в строку Base64.

Значение data может быть любым JavaScript-значением, которое можно привести к строке.

`buffer.INSPECT_MAX_BYTES`

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

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

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

`buffer.kMaxLength`

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

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

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

`buffer.transcode(source, fromEnc, toEnc)`

История

Версия	Изменения
v8.0.0	Параметр `source` теперь может быть `Uint8Array`.
v7.1.0	Добавлена в: v7.1.0

source <Buffer> | <Uint8Array> Экземпляр Buffer или Uint8Array.
fromEnc <строка> Текущая кодировка.
toEnc <строка> Целевая кодировка.
Возвращает: <Buffer>

Перекодирует данный экземпляр 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.

Класс: `SlowBuffer`

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

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

См. Buffer.allocUnsafeSlow(). Этот класс никогда не существовал в том смысле, что конструктор всегда возвращал экземпляр Buffer вместо SlowBuffer.

`new SlowBuffer(size)`

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

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

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

См. Buffer.allocUnsafeSlow().

Константы Buffer

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

`buffer.constants.MAX_LENGTH`

История

Версия	Изменения
v14.0.0	Значение изменено с 2³¹ - 1 на 2³² - 1 на 64-битных архитектурах.
v8.2.0	Добавлена в: v8.2.0

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

На 32-битных архитектурах это значение в настоящее время равно 2³⁰ - 1 (~1 ГБ).

На 64-битных архитектурах это значение в настоящее время равно 2³² - 1 (~4 ГБ).

Оно отражает v8::TypedArray::kMaxLength в основе.

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

`buffer.constants.MAX_STRING_LENGTH`

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

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

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

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

END_OF_DOCUMENT_MARKER

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

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

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

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

Например, если злоумышленник может заставить приложение получить число вместо ожидаемой строки, приложение может вызвать new Buffer(100) вместо new Buffer("100"), что приведёт к выделению буфера размером 100 байт вместо выделения буфера размером 3 байта с содержимым "100". Это часто возможно при использовании вызовов JSON API. Поскольку JSON различает числовые и строковые типы, он позволяет вводить числа там, где приложение, написанное без достаточной валидации входных данных, ожидает всегда получить строку. До Node.js 8.0.0 100-байтовый буфер мог содержать произвольные данные, хранившиеся в памяти, поэтому мог быть использован для раскрытия секретов в памяти удалённому злоумышленнику. С Node.js 8.0.0 раскрытие памяти невозможно, потому что данные заполняются нулями. Однако возможны и другие атаки, такие как создание очень больших буферов на сервере, что приводит к снижению производительности или зависанию из-за исчерпания памяти.

Для повышения надёжности и уменьшения количества ошибок при создании экземпляров Buffer, различные формы конструктора new Buffer() были отменены и заменены отдельными методами Buffer.from(), Buffer.alloc() и Buffer.allocUnsafe().

Разработчики должны перенести все существующие использования конструкторов new Buffer() на одну из этих новых API.

Buffer.from(array) возвращает новый Buffer, содержащий копию переданных октетов.
Buffer.from(arrayBuffer[, byteOffset[, length]]) возвращает новый Buffer, разделяющий ту же выделенную память, что и данный ArrayBuffer.
Buffer.from(buffer) возвращает новый Buffer, содержащий копию содержимого данного Buffer.
Buffer.from(string[, encoding]) возвращает новый Buffer, содержащий копию переданной строки.
Buffer.alloc(size[, fill[, encoding]]) возвращает новый инициализированный Buffer заданного размера. Этот метод медленнее, чем Buffer.allocUnsafe(size), но гарантирует, что вновь созданные экземпляры Buffer никогда не содержат старые, потенциально конфиденциальные данные. Будет выброшено исключение TypeError, если size не является числом.
Buffer.allocUnsafe(size) и Buffer.allocUnsafeSlow(size) каждый возвращают новый неинициализированный Buffer заданного size. Поскольку Buffer неинициализирован, выделенный участок памяти может содержать старые, потенциально конфиденциальные данные.

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

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

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

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

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

Почему `Buffer.allocUnsafe()` и `Buffer.allocUnsafeSlow()` «небезопасны»?

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

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

© 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-v14.x/docs/api/buffer.html

Буфер

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

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

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

Класс: Buffer

Статический метод: 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(object[, offsetOrEncoding[, length]])

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

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

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

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

buf[index]

buf.buffer

buf.byteOffset

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

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

buf.length

buf.parent

buf.readBigInt64BE([offset])

buf.readBigInt64LE([offset])

buf.readBigUInt64BE([offset])

buf.readBigUInt64LE([offset])

buf.readDoubleBE([offset])

buf.readDoubleLE([offset])

buf.readFloatBE([offset])

buf.readFloatLE([offset])

buf.readInt8([offset])

buf.readInt16BE([offset])

buf.readInt16LE([offset])

buf.readInt32BE([offset])

buf.readInt32LE([offset])

buf.readIntBE(offset, byteLength)

buf.readIntLE(offset, byteLength)

buf.readUInt8([offset])

buf.readUInt16BE([offset])

buf.readUInt16LE([offset])

buf.readUInt32BE([offset])

buf.readUInt32LE([offset])

buf.readUIntBE(offset, byteLength)

buf.readUIntLE(offset, byteLength)

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

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

buf.swap16()

buf.swap32()

buf.swap64()

buf.toJSON()

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

buf.values()

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

buf.writeBigInt64BE(value[, offset])

buf.writeBigInt64LE(value[, offset])

buf.writeBigUInt64BE(value[, offset])

buf.writeBigUInt64LE(value[, offset])

buf.writeDoubleBE(value[, offset])

buf.writeDoubleLE(value[, offset])

buf.writeFloatBE(value[, offset])

buf.writeFloatLE(value[, offset])

buf.writeInt8(value[, offset])

buf.writeInt16BE(value[, offset])

buf.writeInt16LE(value[, offset])

buf.writeInt32BE(value[, offset])

buf.writeInt32LE(value[, offset])

buf.writeIntBE(value, offset, byteLength)

buf.writeIntLE(value, offset, byteLength)

buf.writeUInt8(value[, offset])

Класс: `Buffer`

Статический метод: `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(object[, offsetOrEncoding[, length]])`

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

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

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

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

`buf[index]`

`buf.buffer`

`buf.byteOffset`

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

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

`buf.length`

`buf.parent`

`buf.readBigInt64BE([offset])`

`buf.readBigInt64LE([offset])`

`buf.readBigUInt64BE([offset])`

`buf.readBigUInt64LE([offset])`

`buf.readDoubleBE([offset])`

`buf.readDoubleLE([offset])`

`buf.readFloatBE([offset])`

`buf.readFloatLE([offset])`

`buf.readInt8([offset])`

`buf.readInt16BE([offset])`

`buf.readInt16LE([offset])`

`buf.readInt32BE([offset])`

`buf.readInt32LE([offset])`

`buf.readIntBE(offset, byteLength)`

`buf.readIntLE(offset, byteLength)`

`buf.readUInt8([offset])`

`buf.readUInt16BE([offset])`

`buf.readUInt16LE([offset])`

`buf.readUInt32BE([offset])`

`buf.readUInt32LE([offset])`

`buf.readUIntBE(offset, byteLength)`

`buf.readUIntLE(offset, byteLength)`

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

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

`buf.swap16()`

`buf.swap32()`

`buf.swap64()`

`buf.toJSON()`

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

`buf.values()`

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

`buf.writeBigInt64BE(value[, offset])`

`buf.writeBigInt64LE(value[, offset])`

`buf.writeBigUInt64BE(value[, offset])`

`buf.writeBigUInt64LE(value[, offset])`

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

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

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

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

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

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

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

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

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

`buf.writeIntBE(value, offset, byteLength)`

`buf.writeIntLE(value, offset, byteLength)`

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

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

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

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

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