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

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

Модули MJS

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>

Модули CJS

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'): Многобайтовая кодировка символов Юникод. Многие веб-страницы и другие форматы документов используют UTF-8. Это кодировка символов по умолчанию. При декодировании Buffer в строку, которая не содержит исключительно корректные данные UTF-8, символ замены Юникода U+FFFD � будет использоваться для представления этих ошибок.

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

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

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

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

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

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

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

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

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

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

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

Модули MJS

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.

Модули CJS

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

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

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

Модули MJS

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 ]

Модули CJS

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.

Модули MJS

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 ]

Модули CJS

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, используя свойство TypedArray объекта .buffer аналогичным образом. Buffer.from() ведет себя как new Uint8Array() в этом контексте.

Модули MJS

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>

Модули CJS

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.

Модули MJS

import { Buffer } from 'node:buffer';

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

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

Модули CJS

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:

Модули MJS

import { Buffer } from 'node:buffer';

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

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

Модули CJS

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

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

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

• sources <массив строк> | <массив ArrayBuffer> | <массив TypedArray> | <массив DataView> | <массив Blob> Массив строк, <ArrayBuffer>, <TypedArray>, <DataView> или <Blob> объектов, или любое сочетание этих объектов, которые будут храниться в Blob.
• options <объект>
  • endings <строка> Один из 'transparent' или 'native'. При установке в 'native', концы строк в частях исходных строк будут преобразованы в концы строк, используемые в данной платформе, как указано require('node:os').EOL.
  • type <строка> Тип содержимого Blob. Цель параметра type — передать MIME-тип данных, однако проверка формата типа не выполняется.

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

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

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

blob.arrayBuffer()

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

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

blob.size

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

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

• start <число> Начальный индекс.
• end <число> Конечный индекс.
• type <строка> Тип содержимого нового Blob

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

blob.stream()

• Возвращает: <Поток чтения>

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

blob.text()

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

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

blob.type

• Тип: <строка>

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

Blob объекты и MessageChannel

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

Модули MJS

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

Модули CJS

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

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

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

MJS-модули

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5);

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

CJS-модули

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

MJS-модули

import { Buffer } from 'node:buffer';

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

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

CJS-модули

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

MJS-модули

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>

CJS-модули

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.

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

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

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

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

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

MJS-модули

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>

CJS-модули

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>

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

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

• size <целое> Желаемая длина нового 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 , выделения размером менее 4 КБ берутся из одного предварительно выделенного Buffer. Это позволяет приложениям избежать накладных расходов на сборку мусора при создании многих индивидуально выделенных экземпляров Buffer . Этот подход улучшает как производительность, так и использование памяти, устраняя необходимость отслеживать и очищать большое количество отдельных объектов ArrayBuffer.

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

MJS-модули

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

CJS-модули

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

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

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

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

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

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

Модули MJS

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

Модули CJS

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)

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

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

Модули MJS

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

Модули CJS

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

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

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

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

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

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

Модули MJS

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

Модули CJS

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

• view <TypedArray> Копируемый view.
• offset <целое число> Начальный смещение в view. По умолчанию: 0.
• length <целое число> Количество элементов из view для копирования. По умолчанию: view.length - offset.

Копирует подлежащую память 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)

• array <массив целых чисел>

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

Модули MJS

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

Модули CJS

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

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

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

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

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

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

MJS модули

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>

CJS модули

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.

MJS модули

import { Buffer } from 'node:buffer';

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

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

CJS модули

const { Buffer } = require('node:buffer');

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

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

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

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

MJS модули

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>

CJS модули

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)

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

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

MJS модули

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

CJS модули

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

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

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

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

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

MJS модули

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>

CJS модули

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

MJS модули

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>

CJS модули

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>

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

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

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

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

MJS модули

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

CJS модули

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

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

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

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

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

MJS модули

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

CJS модули

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)

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

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

MJS модули

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

CJS модули

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

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

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

buf[index]

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

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

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

MJS модули

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

CJS модули

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 для получения подробностей.

MJS модули

import { Buffer } from 'node:buffer';

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

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

CJS модули

const { Buffer } = require('node:buffer');

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

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

buf.byteOffset

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

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

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

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

MJS модули

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

CJS модули

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

• target <Buffer> | <Uint8Array> A 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 при сортировке.

Модули MJS

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

Модули CJS

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

Модули MJS

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

Модули CJS

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

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

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

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

Модули MJS

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!!!!!!!!!!!!!

Модули CJS

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!!!!!!!!!!!!!

Модули MJS

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

Модули CJS

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

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

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

Модули MJS

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]

Модули CJS

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)

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

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

Модули MJS

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

Модули CJS

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

• 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 будет заполнен:

Модули MJS

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>

Модули CJS

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, или целое число. Если полученное целое число больше 255 (десятичный), buf будет заполнен значением value & 255.

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

Модули MJS

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>

Модули CJS

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 содержит недопустимые символы, она усекается; если не остаётся допустимых данных для заполнения, выбрасывается исключение:

Модули MJS

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.

Модули CJS

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

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

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

MJS модули

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

CJS модули

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

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

Если value:

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

MJS модули

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

CJS модули

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

MJS модули

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

CJS модули

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

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

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

MJS модули

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

CJS модули

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

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

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

MJS модули

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

CJS модули

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

MJS модули

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

CJS модули

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

• <целое>

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

MJS модули

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

CJS модули

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

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

buf.readBigInt64BE([offset])

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

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

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

buf.readBigInt64LE([offset])

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

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

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

buf.readBigUInt64BE([offset])

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

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

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

MJS модули

import { Buffer } from 'node:buffer';

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

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

CJS модули

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

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

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

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

MJS модули

import { Buffer } from 'node:buffer';

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

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

CJS модули

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

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

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

MJS модули

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

CJS модули

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

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

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

MJS модули

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.

CJS модули

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

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

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

MJS модули

import { Buffer } from 'node:buffer';

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

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

CJS модули

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

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

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

MJS модули

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.

CJS модули

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

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

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

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

MJS модули

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.

CJS модули

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

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

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

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

MJS модули

import { Buffer } from 'node:buffer';

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

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

CJS модули

const { Buffer } = require('node:buffer');

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

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

buf.readInt16LE([offset])

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

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

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

MJS модули

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.

CJS модули

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

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

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

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

Модули CJS

const { Buffer } = require('node:buffer');

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

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

buf.readInt32LE([offset])

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

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

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

Модули MJS

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.

Модули CJS

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)

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

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

Модули MJS

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.

Модули CJS

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)

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

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

Модули MJS

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

Модули CJS

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

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

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

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

Модули MJS

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.

Модули CJS

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

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

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

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

Модули MJS

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

Модули CJS

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

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

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

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

Модули MJS

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.

Модули CJS

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

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

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

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

Модули CJS

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

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

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

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

Модули MJS

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.

Модули CJS

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)

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

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

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

Модули MJS

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.

Модули CJS

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)

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

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

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

Модули MJS

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

Модули CJS

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

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

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

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

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

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

Модули MJS

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

Модули CJS

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 , а не начала.

Модули MJS

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

Модули CJS

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

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

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

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

Модули MJS

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

Модули CJS

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

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

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

Модули MJS

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.

Модули CJS

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 большой эндианности:

Модули MJS

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.

Модули CJS

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

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

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

Модули MJS

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.

Модули CJS

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

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

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

Модули MJS

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.

Модули CJS

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

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

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

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

Модули MJS

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>

Модули CJS

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

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

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

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

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

MJS модули

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é

CJS модули

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

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

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

MJS модули

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

CJS модули

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

• 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. Однако, частично закодированные символы не будут записаны.

MJS модули

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

CJS модули

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

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

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

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

MJS модули

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>

CJS модули

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

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

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

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

MJS модули

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>

CJS модули

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

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

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

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

MJS модули

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>

CJS модули

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

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

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

MJS модули

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>

CJS модули

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

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

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

MJS модули

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>

CJS модули

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

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

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

Модули MJS

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>

Модули CJS

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

Модули CJS

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

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

Модули CJS

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

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

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

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

Модули MJS

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>

Модули CJS

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

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

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

Модули CJS

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

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

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

Модули CJS

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

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

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

Модули CJS

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

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32LE(0x05060708, 0);

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

Модули CJS

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)

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

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

Модули MJS

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>

Модули CJS

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)

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

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

Модули MJS

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>

Модули CJS

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

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

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

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

Модули MJS

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>

Модули CJS

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

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

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

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

Модули MJS

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>

Модули CJS

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

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

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

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

Модули MJS

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>

Модули CJS

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

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

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

Модули CJS

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

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

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

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

Модули MJS

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

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

Модули CJS

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)

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

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

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

Модули MJS

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>

Модули CJS

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)

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

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

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

Модули MJS

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>

Модули CJS

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)

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

См. Buffer.from(array).

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

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

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

new Buffer(buffer)

• buffer <Buffer> | <Uint8Array> Существующий Buffer или Uint8Array, из которого нужно скопировать данные.

См. Buffer.from(buffer).

new Buffer(size)

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

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

new Buffer(string[, encoding])

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

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

Класс: File

• Расширяет: <Blob>

Объект File предоставляет информацию о файлах.

new buffer.File(sources, fileName[, options])

• sources <массив строк> | <массив ArrayBuffer> | <массив TypedArray> | <массив DataView> | <массив Blob> | <массив File> Массив строк, <ArrayBuffer>, <TypedArray>, <DataView>, <File> или <Blob> объектов, или любая комбинация таких объектов, которые будут храниться в File.
• fileName <строка> Имя файла.
• options <объект>
  • endings <строка> Одно из 'transparent' или 'native'. Если установлено в 'native', символы конца строки в частях исходного текста будут преобразованы в символы конца строки по умолчанию платформы, как указано в require('node:os').EOL.
  • type <строка> Тип содержимого файла.
  • lastModified <число> Дата последнего изменения файла. По умолчанию: Date.now().

file.name

• Тип: <строка>

Имя File.

file.lastModified

• Тип: <число>

Дата последнего изменения File.

node:buffer модули API

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

buffer.atob(data)

• data <любой> Строка, закодированная в Base64.

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

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

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

buffer.btoa(data)

• data <строка> ASCII-строка (Latin1).

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

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

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

buffer.isAscii(input)

• input <Буфер> | <ArrayBuffer> | <TypedArray> Входные данные для проверки.
• Возвращает: <логическое>

Эта функция возвращает true если input содержит только данные, кодированные в ASCII, в том числе в случае, когда input пусто.

Выбрасывает исключение, если input является отсоединённым буфером массива.

buffer.isUtf8(input)

• input <Буфер> | <ArrayBuffer> | <TypedArray> Входные данные для проверки.
• Возвращает: <логическое>

Эта функция возвращает true если input содержит только данные, кодированные в UTF-8, в том числе в случае, когда input пусто.

Выбрасывает исключение, если input является отсоединённым буфером массива.

buffer.INSPECT_MAX_BYTES

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

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

buffer.kMaxLength

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

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

buffer.kStringMaxLength

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

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

buffer.resolveObjectURL(id)

• id <строка> Строка URL 'blob:nodedata:... возвращенная предыдущим вызовом URL.createObjectURL().
• Возвращает: <Blob>

Разрешает 'blob:nodedata:...' связанный объект <Blob>, зарегистрированный с помощью предыдущего вызова URL.createObjectURL().

buffer.transcode(source, fromEnc, toEnc)

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

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

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

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

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

Модули MJS

import { Buffer, transcode } from 'node:buffer';

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

Модули CJS

const { Buffer, transcode } = require('node:buffer');

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

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

Класс: SlowBuffer

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

new SlowBuffer(size)

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

См. Buffer.allocUnsafeSlow().

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

buffer.constants.MAX_LENGTH

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

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

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

Отражает v8::TypedArray::kMaxLength под капотом.

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

buffer.constants.MAX_STRING_LENGTH

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

Представляет максимальную length, которую может содержать примитив string, подсчитывая в кодовых единицах 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 никогда не содержат устаревших, потенциально конфиденциальных данных. Будет брошено исключение TypeError, если size не является числом.
• Buffer.allocUnsafe(size) и Buffer.allocUnsafeSlow(size) каждый возвращают новый неинициализированный Buffer заданного size. Поскольку Buffer не инициализирован, выделенный фрагмент памяти может содержать устаревшие, потенциально конфиденциальные данные.

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

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

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