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

При преобразовании между 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 и имени файла» в соответствии со RFC 4648, Раздел 5. Пробельные символы, такие как пробелы, табуляции и новые строки, содержащиеся в строке Base64, игнорируются.

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

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

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

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

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

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

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(), если возвращаемый charset находится в списке, указанном в спецификации WHATWG, возможно, сервер на самом деле вернул данные, закодированные в 'win-1252', и использование кодировки 'latin1' может некорректно декодировать символы.

Буферы и TypedArrays

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

Class: Blob

A Blob encapsulates immutable, raw data that can be safely shared across multiple worker threads.

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. Несовпадающие пары суррогатов в каждой части строки будут заменены символами замены Юникода 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>

Возвращает новый 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 <строка> | <Буфер> | <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. Пустой Buffer создаётся, если size равно 0.

Базовая память для экземпляров 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 <строка> | <Буфер> | <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 <Буфер> | <Uint8Array>
• buf2 <Буфер> | <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 <Буфер[]> | <Uint8Array[]> Список экземпляров Buffer или Uint8Array для конкатенации.
• totalLength <целое число> Общая длина экземпляров Buffer в list после конкатенации.
• Возвращаемое значение: <Буфер>

Возвращает новый 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> Копируемый <TypedArray>.
• 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, используя array байт в диапазоне 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 обрабатываются как массив. Для создания 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, создаваемый Buffer будет использовать ту же выделенную память, что и базовая память 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 меньшего, чем 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 <Буфер> | <Uint8Массив> Buffer или Uint8Array для сравнения с buf.
• targetStart <целое> Смещение в target для начала сравнения. По умолчанию: 0.
• targetEnd <целое> Смещение в target для окончания сравнения (не включая). По умолчанию: target.length.
• sourceStart <целое> Смещение в buf для начала сравнения. По умолчанию: 0.
• sourceEnd <целое> Смещение в buf для окончания сравнения (не включая). По умолчанию: buf.length.
• Возвращает: <целое>

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

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

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

Модули 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()

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

Создаёт и возвращает итератор пар [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 <Буфер> | <Uint8Array> A Buffer или Uint8Array для сравнения с buf.
• Возвращает: <логическое>

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

Если value:

• строка, value интерпретируется в соответствии с кодировкой символов в encoding.
• массив Buffer или 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 <строка> | <Буфер> | <Uint8Array> | <целое число> То, что нужно найти.
• byteOffset <целое число> С какой позиции начинать поиск в buf. Если отрицательное, то смещение рассчитывается от конца buf. По умолчанию: buf.length - 1.
• encoding <строка> Если value является строкой, это кодировка, используемая для определения двоичного представления строки, которая будет искаться в 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 бита из buf по указанному offset.

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

buf.readBigInt64LE([offset])

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

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

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

buf.readBigUInt64BE([offset])

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

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

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

Читает 64-битное, большого порядка, число с плавающей точкой из 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>

Читает целое число со знаком, big-endian 16 бит, из 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>

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

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

Читает целое число со знаком, little-endian 32 бит, из 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 <integer> Количество байтов, которые нужно пропустить перед началом чтения.
• byteLength <integer> Количество байтов для чтения. Должно удовлетворять 0 < byteLength <= 6.
• Возвращает: <integer>

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

Читает 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.

• start <целое> С какой позиции начнется новое Buffer. По умолчанию: 0.
• end <целое> До какой позиции (не включая) будет продолжаться новое 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 little-endian и UTF-16 big-endian.

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

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

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

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

Записывает 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 <целое> Количество байтов, которое нужно пропустить, прежде чем начать запись. Должно удовлетворять условию: 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <целое> 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 <целое> Количество байтов, которое нужно пропустить, прежде чем начать запись. Должно удовлетворять условию: 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <целое> 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 <number> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <integer> 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 <number> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> 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 <number> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> 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 <integer> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 1. По умолчанию: 0.
• Возвращает: <integer> 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 <integer> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять условию 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer> 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 <integer> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer> 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 <integer> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <integer> 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 <integer> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> 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 <integer> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - 4. По умолчанию: 0.
• Возвращает: <integer> 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 <integer> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - byteLength.
• byteLength <integer> Количество байтов для записи. Должно удовлетворять 0 < byteLength <= 6.
• Возвращает: <integer> 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 <integer> Число, которое будет записано в buf.
• offset <integer> Количество байтов, которые нужно пропустить перед началом записи. Должно удовлетворять 0 <= offset <= buf.length - byteLength.
• byteLength <integer> Количество байтов для записи. Должно удовлетворять 0 < byteLength <= 6.
• Возвращает: <integer> 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 <integer[]> Массив байтов для копирования.

См. 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 <Буфер> | <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 <Буфер> | <Массив байтов> | <Типизированный массив> Входные данные для проверки.
• Возвращает: <логическое>

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

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

buffer.isUtf8(input)

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

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

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

buffer.INSPECT_MAX_BYTES

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

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

• <целое> Максимальная длина одного объекта string.

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

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

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