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

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

Модули MJS

import { Buffer } from '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('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 поддерживает только вариант little-endian UTF-16.

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

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

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

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

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

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

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

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

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

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

Модули MJS

import { Buffer } from 'buffer';

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

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

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

Модули CJS

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

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

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

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

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

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

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

В частности:

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

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

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

Модули MJS

import { Buffer } from '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('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 '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('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 '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('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 'buffer';

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

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

Модули CJS

const { Buffer } = require('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 'buffer';

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

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

Модули CJS

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

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

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

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

Класс: Blob

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

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

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

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

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

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

blob.arrayBuffer()

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

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

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

blob.type

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

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

Blob объекты и MessageChannel

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

Модули MJS

import { Blob, Buffer } from 'buffer';
import { setTimeout as delay } from '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, Buffer } = require('buffer');
const { setTimeout: delay } = require('timers/promises');

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

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

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

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

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

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

Класс: Buffer

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

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

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

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

MJS-модули

import { Buffer } from 'buffer';

const buf = Buffer.alloc(5);

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

CJS-модули

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

const buf = Buffer.alloc(5);

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

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

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

MJS-модули

import { Buffer } from 'buffer';

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

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

CJS-модули

const { Buffer } = require('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 '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('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_INVALID_ARG_VALUE.

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

MJS-модули

import { Buffer } from '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('buffer');

const buf = Buffer.allocUnsafe(10);

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

buf.fill(0);

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

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

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

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

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

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

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

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

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

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

MJS-модули

import { Buffer } from '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('buffer');

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

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

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

    store.push(sb);
  }
});

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

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

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

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

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

Модули MJS

import { Buffer } from '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('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 <Буфер> | <Uint8Массив>
• buf2 <Буфер> | <Uint8Массив>
• Возвращаемое значение: <целое> Либо -1, либо 0, либо 1, в зависимости от результата сравнения. Подробнее см. buf.compare().

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

Модули MJS

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

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

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

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

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

Модули MJS

import { Buffer } from '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('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.from(array)

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

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

Модули MJS

import { Buffer } from '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('buffer');

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

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

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

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

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

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

Модули MJS

import { Buffer } from '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('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 'buffer';

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

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

Модули CJS

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

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

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

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

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

Модули MJS

import { Buffer } from '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('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 <Буфер> | <Uint8Массив> Существующий Buffer или Uint8Array для копирования данных.

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

Модули MJS

import { Buffer } from '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 'buffer';

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

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

Модули CJS

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

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

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

buf.byteOffset

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

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

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

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

Модули MJS

import { Buffer } from 'buffer';

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

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

Модули CJS

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

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

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

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

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

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

• 0 возвращается, если target равно buf
• 1 возвращается, если target должно стоять перед buf при сортировке.
• -1 возвращается, если target должно стоять после buf при сортировке.

Модули MJS

import { Buffer } from '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('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 '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('buffer');

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

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

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

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

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

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

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

Модули MJS

import { Buffer } from '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('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 '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('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 '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('buffer');

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

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

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

buf.equals(otherBuffer)

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

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

Модули MJS

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

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

Модули MJS

import { Buffer } from 'buffer';

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

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

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

Модули CJS

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

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

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

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

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

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

Модули MJS

import { Buffer } from '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('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 '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('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 <строка> | <Buffer> | <Uint8Array> | <целое> Что искать.
• byteOffset <целое> Где начинать поиск в buf. Если отрицательное, смещение рассчитывается от конца buf. По умолчанию: 0.
• encoding <строка> Если value является строкой, это ее кодировка. По умолчанию: 'utf8'.
• Возвращает: <логическое> true если value найдено в buf, false в противном случае.

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

Модули MJS

import { Buffer } from '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('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 <строка> | <Buffer> | <Uint8Array> | <целое> Что искать.
• byteOffset <целое> С какого места начинать поиск в buf. Если отрицательное, то смещение вычисляется с конца buf. По умолчанию: 0.
• encoding <строка> Если value — это строка, это кодировка, используемая для определения двоичного представления строки, которое будет искаться в buf. По умолчанию: 'utf8'.
• Возвращает: <целое> Индекс первого вхождения value в buf, или -1 если buf не содержит value.

Если value:

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

Модули MJS

import { Buffer } from '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('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 '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('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 '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('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 <строка> | <Buffer> | <Uint8Array> | <целое> Что искать.
• byteOffset <целое> С какого места начинать поиск в buf. Если отрицательное, то смещение вычисляется с конца buf. По умолчанию: buf.length - 1.
• encoding <строка> Если value — это строка, это кодировка, используемая для определения двоичного представления строки, которое будет искаться в buf. По умолчанию: 'utf8'.
• Возвращает: <целое> Индекс последнего вхождения value в buf, или -1 если buf не содержит value.

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

Модули MJS

import { Buffer } from '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('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 '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('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 '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('buffer');

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

const buf = Buffer.alloc(1234);

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

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

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

buf.parent

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

buf.readBigInt64BE([offset])

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

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

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

buf.readBigInt64LE([offset])

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

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

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

buf.readBigUInt64BE([offset])

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

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

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

Модули MJS

import { Buffer } from 'buffer';

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

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

Модули CJS

const { Buffer } = require('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 'buffer';

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

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

CJS модули

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

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

MJS модули

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

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

MJS модули

import { Buffer } from 'buffer';

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

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

CJS модули

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

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

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

buf.readFloatLE([offset])

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

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

MJS модули

import { Buffer } from '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('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 <целое> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять 0 <= offset <= buf.length - 1. По умолчанию: 0.
• Возвращает: <целое>

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

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

MJS модули

import { Buffer } from '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('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 <целое> Количество байтов, которые нужно пропустить перед началом чтения. Должно удовлетворять 0 <= offset <= buf.length - 2. По умолчанию: 0.
• Возвращает: <целое>

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

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

MJS модули

import { Buffer } from 'buffer';

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

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

CJS модули

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

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

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

buf.readInt16LE([offset])

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

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

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

MJS модули

import { Buffer } from '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('buffer');

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

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

buf.readInt32BE([offset])

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

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

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

MJS модули

import { Buffer } from 'buffer';

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

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

CJS модули

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

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

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

buf.readInt32LE([offset])

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

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

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

MJS модули

import { Buffer } from '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('buffer');

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

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

buf.readIntBE(offset, byteLength)

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

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

MJS-модули

import { Buffer } from '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('buffer');

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

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

buf.readIntLE(offset, byteLength)

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

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

MJS-модули

import { Buffer } from '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('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 '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('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.
• Возвращает: <целое>

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

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

MJS-модули

import { Buffer } from '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('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.
• Возвращает: <целое>

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

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

MJS-модули

import { Buffer } from 'buffer';

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

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

CJS-модули

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

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

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

buf.readUInt32BE([offset])

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

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

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

MJS-модули

import { Buffer } from 'buffer';

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

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

CJS-модули

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

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

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

buf.readUInt32LE([offset])

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

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

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

MJS-модули

import { Buffer } from 'buffer';

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

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

CJS-модули

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

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

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

buf.readUIntBE(offset, byteLength)

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

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

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

MJS-модули

import { Buffer } from 'buffer';

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

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

CJS-модули

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

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

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

buf.readUIntLE(offset, byteLength)

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

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

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

Модули MJS

import { Buffer } from 'buffer';

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

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

Модули CJS

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

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

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

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

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

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

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

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

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

Модули MJS

import { Buffer } from 'buffer';

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

const buf1 = Buffer.allocUnsafe(26);

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

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

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

buf1[0] = 33;

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

Модули CJS

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

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

const buf1 = Buffer.allocUnsafe(26);

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

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

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

buf1[0] = 33;

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

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

Модули MJS

import { Buffer } from 'buffer';

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

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

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

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

Модули CJS

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

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

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

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

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

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

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

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

Это то же поведение, что и buf.subarray().

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

Модули MJS

import { Buffer } from '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

Модули CJS

const { Buffer } = require('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

buf.swap16()

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

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

Модули MJS

import { Buffer } from '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 <целое> Количество байтов, пропускаемых перед началом записи. Должно удовлетворять условию: 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <целое> offset плюс количество записанных байтов.

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

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

MJS модули

import { Buffer } from '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('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 <целое> Количество байтов, пропускаемых перед началом записи. Должно удовлетворять условию: 0 <= offset <= buf.length - 8. По умолчанию: 0.
• Возвращает: <целое> offset плюс количество записанных байтов.

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

MJS модули

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

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

MJS модули

import { Buffer } from '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('buffer');

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleBE(123.456, 0);

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

buf.writeDoubleLE(value[, offset])

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

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

MJS модули

import { Buffer } from '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('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 'buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

Модули CJS

const { Buffer } = require('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 'buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

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

Модули CJS

const { Buffer } = require('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 '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('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 'buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

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

Модули CJS

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

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

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

buf.writeInt16LE(value[, offset])

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

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

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

Модули MJS

import { Buffer } from 'buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

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

Модули CJS

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

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

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

buf.writeInt32BE(value[, offset])

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

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

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

Модули MJS

import { Buffer } from 'buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

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

Модули CJS

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

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

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

buf.writeInt32LE(value[, offset])

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

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

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

Модули MJS

import { Buffer } from 'buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32LE(0x05060708, 0);

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

Модули CJS

const { Buffer } = require('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 '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('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 '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('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 '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('buffer');

const buf = Buffer.allocUnsafe(4);

buf.writeUInt8(0x3, 0);
buf.writeUInt8(0x4, 1);
buf.writeUInt8(0x23, 2);
buf.writeUInt8(0x42, 3);

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

buf.writeUInt16BE(value[, offset])

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

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

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

MJS модули

import { Buffer } from '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('buffer');

const buf = Buffer.allocUnsafe(4);

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

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

buf.writeUInt16LE(value[, offset])

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

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

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

MJS модули

import { Buffer } from '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('buffer');

const buf = Buffer.allocUnsafe(4);

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

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

buf.writeUInt32BE(value[, offset])

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

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

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

MJS модули

import { Buffer } from 'buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

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

CJS модули

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

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

buf.writeUInt32LE(value[, offset])

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

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

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

Модули MJS

import { Buffer } from 'buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

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

Модули CJS

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

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

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

buf.writeUIntBE(value, offset, byteLength)

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

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

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

Модули MJS

import { Buffer } from '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('buffer');

const buf = Buffer.allocUnsafe(6);

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

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

buf.writeUIntLE(value, offset, byteLength)

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

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

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

Модули MJS

import { Buffer } from '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('buffer');

const buf = Buffer.allocUnsafe(6);

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

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

new Buffer(array)

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

См. Buffer.from(array).

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

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

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

new Buffer(buffer)

• buffer <Буфер> | <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]).

buffer модули API

Хотя объект Buffer доступен в глобальной области, существуют дополнительные API, связанные с Buffer, доступные только через модуль buffer, к которому обращаются с помощью require('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 (Latin-1).

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

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

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

buffer.INSPECT_MAX_BYTES

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

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

buffer.kMaxLength

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

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

buffer.kStringMaxLength

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

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

buffer.resolveObjectURL(id)

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

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

buffer.transcode(source, fromEnc, toEnc)

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

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

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

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

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

Модули MJS

import { Buffer, transcode } from 'buffer';

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

Модули CJS

const { Buffer, transcode } = require('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.

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

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

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

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

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

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

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

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

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

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

Опция командной строки --zero-fill-buffers

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

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

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

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

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