Spec-Zone.ru › Node.js 22 LTS

Buffer

Стабильность: 2 - Стабильный

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

История
Версия Изменения
v15.7.0, v14.18.0

Добавлена кодировка base64url.
v6.4.0

Добавлена latin1 как псевдоним binary.
v5.0.0

Удалены устаревшие кодировки raw и raws.

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

console.log(Buffer.from('fhqwhgads', 'utf8'));
// Prints: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'));
// Prints: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

Буферы Node.js принимают строки кодировок во всех вариантах регистра. Например, UTF-8 можно указать как 'utf8', 'UTF8' или 'uTf8'.

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

  • 'utf8' (псевдоним: 'utf-8'): многобайтовая кодировка символов Unicode. Многие веб-страницы и другие форматы документов используют UTF-8. Это кодировка символов по умолчанию. При декодировании Buffer в строку, не содержащую исключительно корректные данные UTF-8, для представления ошибок будет использоваться символ замены Unicode U+FFFD �.

  • 'utf16le' (псевдоним: 'utf-16le'): многобайтовая кодировка символов Unicode. В отличие от 'utf8', каждый символ в строке кодируется с использованием 2 или 4 байтов. Node.js поддерживает только вариант с порядком от младшего к старшему для UTF-16.

  • 'latin1': Latin-1 — это ISO-8859-1. Эта кодировка символов поддерживает только символы Unicode в диапазоне от U+0000 до U+00FF. Каждый символ кодируется одним байтом. Символы, не попадающие в этот диапазон, усекаются и отображаются на символы из этого диапазона.

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

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

  • 'base64': кодировка Base64. При создании Buffer из строки эта кодировка также корректно принимает «алфавит, безопасный для URL-адресов и имён файлов», указанный в RFC 4648, раздел 5. Пробельные символы, такие как пробелы, табуляции и символы новой строки, содержащиеся в строке, закодированной в base64, игнорируются.

  • 'base64url': кодировка base64url, указанная в RFC 4648, раздел 5. При создании Buffer из строки эта кодировка также корректно принимает обычные строки, закодированные в base64. При кодировании Buffer в строку эта кодировка не добавляет заполнение.

  • 'hex': каждый байт кодируется двумя шестнадцатеричными символами. При декодировании строк, состоящих не только из чётного числа шестнадцатеричных символов, может произойти усечение данных. См. пример ниже.

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

  • 'ascii': только для 7-битных данных ASCII. При кодировании строки в Buffer это эквивалентно использованию 'latin1'. При декодировании Buffer в строку эта кодировка дополнительно сбрасывает старший бит каждого байта перед декодированием как 'latin1'. Как правило, нет причин использовать эту кодировку, поскольку 'utf8' (или, если известно, что данные содержат только ASCII, 'latin1') будет лучшим выбором для кодирования или декодирования текста, содержащего только ASCII. Она предоставляется только для обратной совместимости.

  • 'binary': псевдоним 'latin1'. Название этой кодировки может вводить в заблуждение, поскольку все перечисленные здесь кодировки преобразуют строки в двоичные данные и обратно. Для преобразования строк в Bufferы обычно подходит 'utf8'.

  • 'ucs2', 'ucs-2': псевдонимы 'utf16le'. Раньше UCS-2 обозначал вариант UTF-16, не поддерживавший символы с кодовыми точками выше U+FFFF. В Node.js такие кодовые точки поддерживаются всегда.

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

Buffer.from('1634', 'hex');
// Prints <Buffer 16 34>, all data represented.
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

История
Версия Изменения
v3.0.0

Класс Buffer теперь наследуется от Uint8Array.

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

В частности:

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

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

  • Передача Buffer конструктору <TypedArray> копирует содержимое Buffer, интерпретируя его как массив целых чисел, а не как последовательность байтов целевого типа.
Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(uint32array);

// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]
CommonJS
const { Buffer } = require('node:buffer');

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

console.log(uint32array);

// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]
  • Передача базового <ArrayBuffer> объекта Buffer создаёт <TypedArray>, использующий одну и ту же память с Buffer.
Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(uint16array);

// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]
CommonJS
const { Buffer } = require('node:buffer');

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

console.log(uint16array);

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const arr = new Uint16Array(2);

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

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

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

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

arr[1] = 6000;

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 70 17>
CommonJS
const { Buffer } = require('node:buffer');

const arr = new Uint16Array(2);

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

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

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

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

arr[1] = 6000;

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.length);
// Prints: 16
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

for (const b of buf) {
  console.log(b);
}
// Prints:
//   1
//   2
//   3
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

Класс: Blob

История
Версия Изменения
v18.0.0, v16.17.0

Больше не является экспериментальным.
v15.7.0, v14.18.0

Добавлено в: v15.7.0, v14.18.0

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

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

История
Версия Изменения
v16.7.0

Добавлен стандартный параметр endings для замены окончаний строк и удалён нестандартный параметр encoding.
v15.7.0, v14.18.0

Добавлено в: v15.7.0, v14.18.0
  • sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> Массив строк, объектов <ArrayBuffer>, <TypedArray>, <DataView> или <Blob> либо любых их сочетаний, которые будут сохранены в Blob.
  • options <Object>
    • endings <string> Одно из значений: 'transparent' или 'native'. Если задано значение 'native', окончания строк в строковых частях источника будут преобразованы в окончания строк, принятые на платформе, как указано в require('node:os').EOL.
    • type <string> Тип содержимого Blob. Предполагается, что type указывает тип мультимедиа MIME данных, однако формат типа не проверяется.

Создаёт новый объект Blob, содержащий объединённые указанные источники.

Источники <ArrayBuffer>, <TypedArray>, <DataView> и <Buffer> копируются в объект 'Blob', поэтому после создания 'Blob' их можно безопасно изменять.

Строковые источники кодируются как последовательности байтов UTF-8 и копируются в Blob. Несопоставленные суррогатные пары в каждой строковой части заменяются символами замены Unicode U+FFFD.

blob.arrayBuffer()

Добавлено в: v15.7.0, v14.18.0
  • Возвращает: <Promise>

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

blob.bytes()
Добавлено в: v22.3.0

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

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

blob.size

Добавлено в: v15.7.0, v14.18.0

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

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

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

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

blob.stream()

Добавлено в: v16.7.0
  • Возвращает: <ReadableStream>

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

blob.text()

Добавлено в: v15.7.0, v14.18.0
  • Возвращает: <Promise>

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

blob.type

Добавлено в: v15.7.0, v14.18.0
  • Тип: <string>

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

Объекты Blob и MessageChannel

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

Модули JavaScript
import { Blob } from 'node:buffer';
import { setTimeout as delay } from 'node:timers/promises';

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

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

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

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

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

// The Blob is still usable after posting.
blob.text().then(console.log);
CommonJS
const { Blob } = require('node:buffer');
const { setTimeout: delay } = require('node:timers/promises');

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

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

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

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

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

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

Класс: Buffer

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

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

История
Версия Изменения
v20.0.0

При недопустимых аргументах вместо ERR_INVALID_ARG_VALUE теперь выбрасывается ERR_INVALID_ARG_TYPE или ERR_OUT_OF_RANGE.
v15.0.0

При недопустимых аргументах вместо ERR_INVALID_OPT_VALUE теперь выбрасывается ERR_INVALID_ARG_VALUE.
v10.0.0

Попытка заполнить буфер ненулевой длины буфером нулевой длины вызывает исключение.
v10.0.0

Указание недопустимой строки для fill вызывает исключение.
v8.9.3

Указание недопустимой строки для fill теперь приводит к созданию буфера, заполненного нулями.
v5.10.0

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5);

console.log(buf);
// Prints: <Buffer 00 00 00 00 00>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.alloc(5);

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf);
// Prints: <Buffer 61 61 61 61 61>
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf);
// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

История
Версия Изменения
v20.0.0

При недопустимых аргументах вместо ERR_INVALID_ARG_VALUE теперь выбрасывается ERR_INVALID_ARG_TYPE или ERR_OUT_OF_RANGE.
v15.0.0

При недопустимых аргументах вместо ERR_INVALID_OPT_VALUE теперь выбрасывается ERR_INVALID_ARG_VALUE.
v7.0.0

Передача отрицательного значения size теперь приводит к ошибке.
v5.10.0

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(10);

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

buf.fill(0);

console.log(buf);
// Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(10);

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

buf.fill(0);

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

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

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

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

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

История
Версия Изменения
v20.0.0

При недопустимых аргументах вместо ERR_INVALID_ARG_VALUE теперь выбрасывается ERR_INVALID_ARG_TYPE или ERR_OUT_OF_RANGE.
v15.0.0

При недопустимых аргументах вместо ERR_INVALID_OPT_VALUE теперь выбрасывается ERR_INVALID_ARG_VALUE.
v5.12.0

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

    store.push(sb);
  }
});
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

    store.push(sb);
  }
});

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

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

История
Версия Изменения
v7.0.0

Передача недопустимых данных теперь приводит к ошибке.
v5.10.0

Параметр string теперь может иметь тип TypedArray, DataView или ArrayBuffer.
v0.1.90

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

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

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

История
Версия Изменения
v8.0.0

Аргументы теперь могут быть Uint8Arrayами.
v0.11.13

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(arr.sort(Buffer.compare));
// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (This result is equal to: [buf2, buf1].)
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

История
Версия Изменения
v8.0.0

Элементы list теперь могут быть Uint8Arrayами.
v0.7.11

Добавлено в: v0.7.11
  • list <Buffer[]> | <Uint8Array[]> Список экземпляров Buffer или <Uint8Array> для объединения.
  • totalLength <integer> Общая длина экземпляров Buffer в list после объединения.
  • Возвращает: <Buffer>

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

console.log(bufA);
// Prints: <Buffer 00 00 00 00 ...>
console.log(bufA.length);
// Prints: 42
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

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

Добавлено в: v19.8.0, v18.16.0
  • view <TypedArray> Объект <TypedArray> для копирования.
  • offset <integer> Начальное смещение внутри view. По умолчанию: 0.
  • length <integer> Количество элементов, копируемых из view. По умолчанию: view.length - offset.
  • Возвращает: <Buffer>

Копирует базовую память view в новый Buffer.

const u16 = new Uint16Array([0, 0xffff]);
const buf = Buffer.copyBytesFrom(u16, 1, 1);
u16[1] = 0;
console.log(buf.length); // 2
console.log(buf[0]); // 255
console.log(buf[1]); // 255 copy

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

Добавлено в: v5.10.0
  • array <integer[]>
  • Возвращает: <Buffer>

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const arr = new Uint16Array(2);

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

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

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

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

console.log(buf);
// Prints: <Buffer 88 13 70 17>
CommonJS
const { Buffer } = require('node:buffer');

const arr = new Uint16Array(2);

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.length);
// Prints: 2
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

const buf = Buffer.from(arrB.buffer);
console.log(buf);
// Prints: <Buffer 63 64 65 66>
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

buf1[0] = 0x61;

console.log(buf1.toString());
// Prints: auffer
console.log(buf2.toString());
// Prints: buffer
CommonJS
const { Buffer } = require('node:buffer');

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

buf1[0] = 0x61;

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf1.toString());
// Prints: this is a tést
console.log(buf2.toString());
// Prints: this is a tést
console.log(buf1.toString('latin1'));
// Prints: this is a tést
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

Добавлено в: v0.1.101
  • obj <Object>
  • Возвращает: <boolean>

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

Модули JavaScript
import { Buffer } from 'node:buffer';

Buffer.isBuffer(Buffer.alloc(10)); // true
Buffer.isBuffer(Buffer.from('foo')); // true
Buffer.isBuffer('a string'); // false
Buffer.isBuffer([]); // false
Buffer.isBuffer(new Uint8Array(1024)); // false
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

console.log(Buffer.isEncoding(''));
// Prints: false
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

Добавлено в: v0.11.3
  • Тип: <integer> По умолчанию: 8192

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

buf[index]

  • index <integer>

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

console.log(buf.toString('utf8'));
// Prints: Node.js
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

buf.buffer

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buffer.buffer === arrayBuffer);
// Prints: true
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.byteOffset

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

// When casting the Node.js Buffer to an Int8Array, use the byteOffset
// to refer only to the part of `nodeBuffer.buffer` that contains the memory
// for `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

История
Версия Изменения
v8.0.0

Параметр target теперь может иметь тип Uint8Array.
v5.11.0

Теперь поддерживаются дополнительные параметры для указания смещений.
v0.11.13

Добавлено в: v0.11.13
  • target <Buffer> | <Uint8Array> Объект Buffer или <Uint8Array>, с которым сравнивается buf.
  • targetStart <integer> Смещение в target, с которого начинается сравнение. По умолчанию: 0.
  • targetEnd <integer> Смещение в target, на котором заканчивается сравнение (не включая его). По умолчанию: target.length.
  • sourceStart <integer> Смещение в buf, с которого начинается сравнение. По умолчанию: 0.
  • sourceEnd <integer> Смещение в buf, на котором заканчивается сравнение (не включая его). По умолчанию: buf.length.
  • Возвращает: <integer>

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

  • Возвращается 0, если target совпадает с buf
  • Возвращается 1, если при сортировке target должно располагаться перед buf.
  • Возвращается -1, если при сортировке target должно располагаться после buf.
Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf1.compare(buf1));
// Prints: 0
console.log(buf1.compare(buf2));
// Prints: -1
console.log(buf1.compare(buf3));
// Prints: -1
console.log(buf2.compare(buf1));
// Prints: 1
console.log(buf2.compare(buf3));
// Prints: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare));
// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (This result is equal to: [buf1, buf3, buf2].)
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf1.compare(buf2, 5, 9, 0, 4));
// Prints: 0
console.log(buf1.compare(buf2, 0, 6, 4));
// Prints: -1
console.log(buf1.compare(buf2, 5, 6, 5));
// Prints: 1
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

console.log(buf2.toString('ascii', 0, 25));
// Prints: !!!!!!!!qrst!!!!!!!!!!!!!
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

console.log(buf2.toString('ascii', 0, 25));
// Prints: !!!!!!!!qrst!!!!!!!!!!!!!
Модули JavaScript
import { Buffer } from 'node:buffer';

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

const buf = Buffer.allocUnsafe(26);

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

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

console.log(buf.toString());
// Prints: efghijghijklmnopqrstuvwxyz
CommonJS
const { Buffer } = require('node:buffer');

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

const buf = Buffer.allocUnsafe(26);

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

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

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

buf.entries()

Добавлено в: v1.1.0
  • Возвращает: <Iterator>

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

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

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

buf.equals(otherBuffer)

История
Версия Изменения
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.

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf1.equals(buf2));
// Prints: true
console.log(buf1.equals(buf3));
// Prints: false
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

console.log(c.fill(''));
// Prints: <Buffer 00 00 00 00 00>
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(Buffer.allocUnsafe(5).fill('\u0222'));
// Prints: <Buffer c8 a2 c8 a2 c8>
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(5);

console.log(buf.fill('a'));
// Prints: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'));
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'));
// Throws an exception.
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(5);

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

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

История
Версия Изменения
v8.0.0

Теперь value может иметь тип Uint8Array.
v5.7.0, v4.4.0

При передаче encoding параметр byteOffset больше не требуется.
v1.5.0

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

Если value — это:

  • строка, value интерпретируется согласно кодировке символов в encoding.
  • объект Buffer или <Uint8Array>, value используется целиком. Чтобы сравнить часть Buffer, используйте buf.subarray.
  • число, value интерпретируется как беззнаковое 8-битное целочисленное значение от 0 до 255.
Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'));
// Prints: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'));
// Prints: 6
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

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

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

Если value — пустая строка или пустой Buffer, а byteOffset меньше buf.length, возвращается byteOffset. Если value пусто, а byteOffset больше или равно buf.length, возвращается buf.length.

buf.keys()

Добавлено в: v1.1.0
  • Возвращает: <Iterator>

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

for (const key of buf.keys()) {
  console.log(key);
}
// Prints:
//   0
//   1
//   2
//   3
//   4
//   5
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.lastIndexOf(value[, 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.

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'));
// Prints: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'));
// Prints: 4
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

// Passing a byteOffset that coerces to 0.
// Prints: -1, equivalent to passing 0.
console.log(b.lastIndexOf('b', null));
console.log(b.lastIndexOf('b', []));
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

Если value — пустая строка или пустой Buffer, возвращается byteOffset.

buf.length

Добавлено в: v0.1.90
  • Тип: <integer>

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

const buf = Buffer.alloc(1234);

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

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

console.log(buf.length);
// Prints: 1234
CommonJS
const { Buffer } = require('node:buffer');

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

const buf = Buffer.alloc(1234);

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

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

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

buf.parent

Устарело начиная с: 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-битное целое число в порядке от старшего байта к младшему из buf по указанному offset.

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

buf.readBigInt64LE([offset])

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

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

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

buf.readBigUInt64BE([offset])

История
Версия Изменения
v14.10.0, v12.19.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-битное целое число в порядке от старшего байта к младшему из buf по указанному offset.

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readBigUInt64BE(0));
// Prints: 4294967295n
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readBigUInt64LE([offset])

История
Версия Изменения
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-битное целое число в порядке от младшего байта к старшему из buf по указанному offset.

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readBigUInt64LE(0));
// Prints: 18446744069414584320n
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readDoubleBE([offset])

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readDoubleBE(0));
// Prints: 8.20788039913184e-304
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readDoubleLE([offset])

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readDoubleLE(0));
// Prints: 5.447603722011605e-270
console.log(buf.readDoubleLE(1));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readFloatBE([offset])

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readFloatBE(0));
// Prints: 2.387939260590663e-38
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readFloatLE([offset])

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readFloatLE(0));
// Prints: 1.539989614439558e-36
console.log(buf.readFloatLE(1));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readInt8([offset])

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.5.0

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readInt8(0));
// Prints: -1
console.log(buf.readInt8(1));
// Prints: 5
console.log(buf.readInt8(2));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readInt16BE([offset])

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readInt16BE(0));
// Prints: 5
CommonJS
const { Buffer } = require('node: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 <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 2. По умолчанию: 0.
  • Возвращает: <integer>

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readInt16LE(0));
// Prints: 1280
console.log(buf.readInt16LE(1));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readInt32BE([offset])

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readInt32BE(0));
// Prints: 5
CommonJS
const { Buffer } = require('node: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 <integer> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять условию 0 <= offset <= buf.length - 4. По умолчанию: 0.
  • Возвращает: <integer>

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readInt32LE(0));
// Prints: 83886080
console.log(buf.readInt32LE(1));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readIntBE(offset, byteLength)

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение и byteLength больше не преобразуются неявно в uint32.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readIntBE(0, 6).toString(16));
// Prints: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16));
// Throws ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readIntLE(offset, byteLength)

История
Версия Изменения
v10.0.0

Удалён noAssert; смещение и byteLength больше не преобразуются неявно в uint32.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readIntLE(0, 6).toString(16));
// Prints: -546f87a9cbee
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readUInt8([offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна под именем buf.readUint8().
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.5.0

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt8(0));
// Prints: 1
console.log(buf.readUInt8(1));
// Prints: 254
console.log(buf.readUInt8(2));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readUInt16BE([offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна под именем buf.readUint16BE().
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt16BE(0).toString(16));
// Prints: 1234
console.log(buf.readUInt16BE(1).toString(16));
// Prints: 3456
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readUInt16LE([offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна под именем buf.readUint16LE().
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt16LE(0).toString(16));
// Prints: 3412
console.log(buf.readUInt16LE(1).toString(16));
// Prints: 5634
console.log(buf.readUInt16LE(2).toString(16));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readUInt32BE([offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна под именем buf.readUint32BE().
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt32BE(0).toString(16));
// Prints: 12345678
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readUInt32LE([offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна под именем buf.readUint32LE().
v10.0.0

Удалён noAssert; смещение больше не преобразуется неявно в uint32.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt32LE(0).toString(16));
// Prints: 78563412
console.log(buf.readUInt32LE(1).toString(16));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readUIntBE(offset, byteLength)

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна под именем buf.readUintBE().
v10.0.0

Удалён noAssert; смещение и byteLength больше не преобразуются неявно в uint32.
v0.11.15

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readUIntBE(0, 6).toString(16));
// Prints: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16));
// Throws ERR_OUT_OF_RANGE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf.readUIntLE(offset, byteLength)

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна под именем buf.readUintLE().
v10.0.0

Удалён noAssert; смещение и byteLength больше не преобразуются неявно в uint32.
v0.11.15

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

console.log(buf.readUIntLE(0, 6).toString(16));
// Prints: ab9078563412
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

const buf1 = Buffer.allocUnsafe(26);

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

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

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

buf1[0] = 33;

console.log(buf2.toString('ascii', 0, buf2.length));
// Prints: !bc
CommonJS
const { Buffer } = require('node:buffer');

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

const buf1 = Buffer.allocUnsafe(26);

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

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

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

buf1[0] = 33;

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

console.log(buf.subarray(-5, -2).toString());
// Prints: uff
// (Equivalent to buf.subarray(1, 4).)
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

История
Версия Изменения
v17.5.0, v16.15.0

Метод buf.slice() объявлен устаревшим.
v7.0.0

Теперь перед выполнением любых вычислений все смещения преобразуются в целые числа.
v7.1.0, v6.9.2

Теперь при преобразовании смещений в целые числа корректно обрабатываются значения вне диапазона 32-битных целых чисел.
v0.3.0

Добавлено в: v0.3.0
  • start <integer> Позиция начала нового Buffer. По умолчанию: 0.
  • end <integer> Позиция конца нового Buffer (не включительно). По умолчанию: buf.length.
  • Возвращает: <Buffer>
Стабильность: 0 — Устарело: вместо этого используйте buf.subarray.

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

buf.swap16()

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

buf1.swap16();

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

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

buf2.swap16();
// Throws ERR_INVALID_BUFFER_SIZE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf1.swap16();

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

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

buf2.swap16();
// Throws ERR_INVALID_BUFFER_SIZE.

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le');
buf.swap16(); // Convert to big-endian UTF-16 text.
CommonJS
const { Buffer } = require('node:buffer');

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

buf.swap32()

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

buf1.swap32();

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

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

buf2.swap32();
// Throws ERR_INVALID_BUFFER_SIZE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf1.swap32();

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

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

buf2.swap32();
// Throws ERR_INVALID_BUFFER_SIZE.

buf.swap64()

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

buf1.swap64();

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

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

buf2.swap64();
// Throws ERR_INVALID_BUFFER_SIZE.
CommonJS
const { Buffer } = require('node:buffer');

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

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

buf1.swap64();

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

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

buf2.swap64();
// Throws ERR_INVALID_BUFFER_SIZE.

buf.toJSON()

Добавлено в: v0.9.2
  • Возвращает: <Object>

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

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

console.log(copy);
// Prints: <Buffer 01 02 03 04 05>
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf1 = Buffer.allocUnsafe(26);

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

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

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

console.log(buf2.toString('hex'));
// Prints: 74c3a97374
console.log(buf2.toString('utf8', 0, 3));
// Prints: té
console.log(buf2.toString(undefined, 0, 3));
// Prints: té
CommonJS
const { Buffer } = require('node:buffer');

const buf1 = Buffer.allocUnsafe(26);

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

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

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

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

buf.values()

Добавлено в: v1.1.0
  • Возвращает: <Iterator>

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

Модули JavaScript
import { Buffer } from 'node:buffer';

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

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

for (const value of buf) {
  console.log(value);
}
// Prints:
//   98
//   117
//   102
//   102
//   101
//   114
CommonJS
const { Buffer } = require('node:buffer');

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

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

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

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(256);

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

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

const buffer = Buffer.alloc(10);

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

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

const buf = Buffer.alloc(256);

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

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

const buffer = Buffer.alloc(10);

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

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

buf.writeBigInt64BE(value[, offset])

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64BE(0x0102030405060708n, 0);

console.log(buf);
// Prints: <Buffer 01 02 03 04 05 06 07 08>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64BE(0x0102030405060708n, 0);

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

buf.writeBigInt64LE(value[, offset])

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64LE(0x0102030405060708n, 0);

console.log(buf);
// Prints: <Buffer 08 07 06 05 04 03 02 01>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64LE(0x0102030405060708n, 0);

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

buf.writeBigUInt64BE(value[, offset])

История
Версия Изменения
v14.10.0, v12.19.0

Эта функция также доступна как buf.writeBigUint64BE().
v12.0.0, v10.20.0

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64BE(0xdecafafecacefaden, 0);

console.log(buf);
// Prints: <Buffer de ca fa fe ca ce fa de>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64BE(0xdecafafecacefaden, 0);

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

buf.writeBigUInt64LE(value[, offset])

История
Версия Изменения
v14.10.0, v12.19.0

Эта функция также доступна как buf.writeBigUint64LE().
v12.0.0, v10.20.0

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64LE(0xdecafafecacefaden, 0);

console.log(buf);
// Prints: <Buffer de fa ce ca fe fa ca de>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64LE(0xdecafafecacefaden, 0);

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

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

buf.writeDoubleBE(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleBE(123.456, 0);

console.log(buf);
// Prints: <Buffer 40 5e dd 2f 1a 9f be 77>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleBE(123.456, 0);

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

buf.writeDoubleLE(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleLE(123.456, 0);

console.log(buf);
// Prints: <Buffer 77 be 9f 1a 2f dd 5e 40>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleLE(123.456, 0);

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

buf.writeFloatBE(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

console.log(buf);
// Prints: <Buffer 4f 4a fe bb>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

buf.writeFloatLE(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

console.log(buf);
// Prints: <Buffer bb fe 4a 4f>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

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

buf.writeInt8(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.5.0

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

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

console.log(buf);
// Prints: <Buffer 02 fe>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(2);

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

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

buf.writeInt16BE(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

console.log(buf);
// Prints: <Buffer 01 02>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

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

buf.writeInt16LE(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

console.log(buf);
// Prints: <Buffer 04 03>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

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

buf.writeInt32BE(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

console.log(buf);
// Prints: <Buffer 01 02 03 04>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

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

buf.writeInt32LE(value[, offset])

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32LE(0x05060708, 0);

console.log(buf);
// Prints: <Buffer 08 07 06 05>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

buf.writeInt32LE(0x05060708, 0);

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

buf.writeIntBE(value, offset, byteLength)

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения и byteLength к uint32 больше не выполняется.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

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

console.log(buf);
// Prints: <Buffer 12 34 56 78 90 ab>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(6);

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

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

buf.writeIntLE(value, offset, byteLength)

История
Версия Изменения
v10.0.0

Удален noAssert, а неявное приведение смещения и byteLength к uint32 больше не выполняется.
v0.11.15

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

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

console.log(buf);
// Prints: <Buffer ab 90 78 56 34 12>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(6);

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

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

buf.writeUInt8(value[, offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна как buf.writeUint8().
v10.0.0

Удален noAssert; неявное приведение смещения к uint32 больше не выполняется.
v0.5.0

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

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

console.log(buf);
// Prints: <Buffer 03 04 23 42>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

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

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

buf.writeUInt16BE(value[, offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна как buf.writeUint16BE().
v10.0.0

Удален noAssert; неявное приведение смещения к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

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

console.log(buf);
// Prints: <Buffer de ad be ef>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

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

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

buf.writeUInt16LE(value[, offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна как buf.writeUint16LE().
v10.0.0

Удален noAssert; неявное приведение смещения к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

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

console.log(buf);
// Prints: <Buffer ad de ef be>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

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

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

buf.writeUInt32BE(value[, offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна как buf.writeUint32BE().
v10.0.0

Удален noAssert; неявное приведение смещения к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

console.log(buf);
// Prints: <Buffer fe ed fa ce>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

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

buf.writeUInt32LE(value[, offset])

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна как buf.writeUint32LE().
v10.0.0

Удален noAssert; неявное приведение смещения к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

console.log(buf);
// Prints: <Buffer ce fa ed fe>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

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

buf.writeUIntBE(value, offset, byteLength)

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна как buf.writeUintBE().
v10.0.0

Удален noAssert; неявное приведение смещения и byteLength к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

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

console.log(buf);
// Prints: <Buffer 12 34 56 78 90 ab>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(6);

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

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

buf.writeUIntLE(value, offset, byteLength)

История
Версия Изменения
v14.9.0, v12.19.0

Эта функция также доступна как buf.writeUintLE().
v10.0.0

Удален noAssert; неявное приведение смещения и byteLength к uint32 больше не выполняется.
v0.5.5

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

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

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

Модули JavaScript
import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

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

console.log(buf);
// Prints: <Buffer ab 90 78 56 34 12>
CommonJS
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(6);

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

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

new Buffer(array)

История
Версия Изменения
v10.0.0

Вызов этого конструктора выдает предупреждение об устаревании, если он выполняется из кода за пределами каталога node_modules.
v7.2.1

Вызов этого конструктора больше не выдает предупреждение об устаревании.
v7.0.0

Теперь вызов этого конструктора выдает предупреждение об устаревании.
v6.0.0

Устарело с версии: v6.0.0
Стабильность: 0 — Устарело: используйте вместо этого Buffer.from(array).
  • array <integer[]> Массив байтов для копирования.

См. 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 <integer> Индекс первого доступного байта. По умолчанию: 0.
  • length <integer> Количество доступных байтов. По умолчанию: 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 <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 <integer> Требуемая длина нового объекта 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 <string> Строка для кодирования.
  • encoding <string> Кодировка string. По умолчанию: 'utf8'.

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

Класс: File

История
Версия Изменения
v20.0.0

Больше не является экспериментальным.
v19.2.0, v18.13.0

Добавлено в: v19.2.0, v18.13.0
  • Наследует: <Blob>

<File> предоставляет сведения о файлах.

new buffer.File(sources, fileName[, options])

Добавлено в: v19.2.0, v18.13.0
  • sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> | <File[]> Массив строк, объектов <ArrayBuffer>, <TypedArray>, <DataView>, <File> или <Blob>, а также любые сочетания таких объектов, которые будут храниться внутри File.
  • fileName <string> Имя файла.
  • options <Object>
    • endings <string> Одно из значений: 'transparent' или 'native'. Если задано значение 'native', символы конца строки в строковых исходных частях будут преобразованы в системный формат конца строки, указанный в require('node:os').EOL.
    • type <string> Тип содержимого файла.
    • lastModified <number> Дата последнего изменения файла. По умолчанию: Date.now().

file.name

Добавлено в: v19.2.0, v18.13.0
  • Тип: <string>

Имя объекта File.

file.lastModified

Добавлено в: v19.2.0, v18.13.0
  • Тип: <number>

Дата последнего изменения объекта File.

node:buffer API модуля

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

buffer.atob(data)

Добавлено в: v15.13.0, v14.17.0
Стабильность: 3 — устаревший API. Вместо него используйте Buffer.from(data, 'base64').
  • data <any> Входная строка в кодировке Base64.

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

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

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

buffer.btoa(data)

Добавлено в: v15.13.0, v14.17.0
Стабильность: 3 — устаревший API. Вместо него используйте buf.toString('base64').
  • data <any> Строка ASCII (Latin1).

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

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

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

buffer.isAscii(input)

Добавлено в: v19.6.0, v18.15.0
  • input <Buffer> | <ArrayBuffer> | <TypedArray> Проверяемые входные данные.
  • Возвращает: <boolean>

Эта функция возвращает true, если input содержит только корректные данные в кодировке ASCII, в том числе если input пуст.

Выбрасывает исключение, если input является отсоединённым буфером массива.

buffer.isUtf8(input)

Добавлено в: v19.4.0, v18.14.0
  • input <Buffer> | <ArrayBuffer> | <TypedArray> Проверяемые входные данные.
  • Возвращает: <boolean>

Эта функция возвращает true, если input содержит только корректные данные в кодировке UTF-8, в том числе если input пуст.

Выбрасывает исключение, если input является отсоединённым буфером массива.

buffer.INSPECT_MAX_BYTES

Добавлено в: v0.5.4
  • Тип: <integer> По умолчанию: 50

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

buffer.kMaxLength

Добавлено в: v3.0.0
  • Тип: <integer> Наибольший допустимый размер одного экземпляра Buffer.

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

buffer.kStringMaxLength

Добавлено в: v3.0.0
  • Тип: <integer> Наибольшая допустимая длина одного экземпляра string.

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

buffer.resolveObjectURL(id)

История
Версия Изменения
v22.17.0

API объявлен стабильным.
v16.7.0

Добавлено в: v16.7.0
  • id <string> Строка URL 'blob:nodedata:..., возвращённая предыдущим вызовом URL.createObjectURL().
  • Возвращает: <Blob>

Находит связанный объект <Blob> для 'blob:nodedata:...', зарегистрированного предыдущим вызовом URL.createObjectURL().

buffer.transcode(source, fromEnc, toEnc)

История
Версия Изменения
v8.0.0

Параметр source теперь может иметь тип Uint8Array.
v7.1.0

Добавлено в: v7.1.0
  • source <Buffer> | <Uint8Array> Экземпляр Buffer или Uint8Array.
  • fromEnc <string> Текущая кодировка.
  • toEnc <string> Целевая кодировка.
  • Возвращает: <Buffer>

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

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

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

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

Модули JavaScript
import { Buffer, transcode } from 'node:buffer';

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

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

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

Класс: SlowBuffer

Устарел с версии: v6.0.0
Стабильность: 0 — устаревший API: вместо него используйте Buffer.allocUnsafeSlow().

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

new SlowBuffer(size)
Устарел с версии: v6.0.0
  • size <integer> Желаемая длина нового SlowBuffer.

См. Buffer.allocUnsafeSlow().

Константы Buffer

Добавлено в: v8.2.0
buffer.constants.MAX_LENGTH
История
Версия Изменения
v22.0.0

На 64-разрядных архитектурах значение изменено на 253 - 1.
v15.0.0

На 64-разрядных архитектурах значение изменено на 232.
v14.0.0

На 64-разрядных архитектурах значение изменено с 231 - 1 на 232 - 1.
v8.2.0

Добавлено в: v8.2.0
  • Тип: <integer> Наибольший допустимый размер одного экземпляра Buffer.

На 32-разрядных архитектурах это значение в настоящее время равно 230 - 1 (около 1 ГиБ).

На 64-разрядных архитектурах это значение в настоящее время равно 253 - 1 (около 8 ПиБ).

Оно соответствует значению v8::TypedArray::kMaxLength, используемому внутри.

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

buffer.constants.MAX_STRING_LENGTH
Добавлено в: v8.2.0
  • Тип: <integer> Наибольшая допустимая длина одного экземпляра string.

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

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

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

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

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

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

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

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

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

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

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

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

Добавлено в: 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> copy

Почему 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-v22.x/docs/api/buffer.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API