buffer

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

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

Строковые источники также копируются в Blob.

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

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

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

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

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

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

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

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

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

Имя File.

Одно из значений: 'transparent' или 'native'. Если задано значение 'native', окончания строк в строковых частях источника будут преобразованы в собственный для платформы формат окончания строк, указанный в import { EOL } from 'node:os'.

Тип содержимого Blob. Предполагается, что type указывает тип MIME данных, однако формат типа не проверяется.

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

const buf1 = Buffer.allocUnsafe(26);

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

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

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

buf1[0] = 33;

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

Записывает string в buf по адресу offset согласно кодировке символов вencoding. Параметр length — это количество байтов для записи. Если в buf недостаточно места для всей строки, будет записана только её часть — string. Однако частично закодированные символы записываться не будут.

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(256);

const len = buf.write('\u00bd + \u00bc = \u00be', 0);

console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`);
// Prints: 12 bytes: ½ + ¼ = ¾

const buffer = Buffer.alloc(10);

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

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

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

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

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

import { Buffer } from 'node:buffer';

const buf1 = Buffer.allocUnsafe(26);

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

console.log(buf1.toString('utf8'));
// Prints: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5));
// Prints: abcde

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

const buf = Buffer.allocUnsafe(26);

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

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

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

Записывает value в buf по указанному адресу offset в порядке от старшего байта к младшему.

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64BE(0x0102030405060708n, 0);

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

Записывает value в buf по указанному адресу offset в порядке от младшего байта к старшему.

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigInt64LE(0x0102030405060708n, 0);

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

Записывает value в buf по указанному адресу offset в порядке от старшего байта к младшему.

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64BE(0xdecafafecacefaden, 0);

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

Записывает value в buf по указанному адресу offset в порядке от младшего байта к старшему

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeBigUInt64LE(0xdecafafecacefaden, 0);

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(6);

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

buf1.swap16();

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

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

buf2.swap16();
// Throws ERR_INVALID_BUFFER_SIZE.

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

import { Buffer } from 'node:buffer';

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

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

import { Buffer } from 'node:buffer';

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

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

buf1.swap32();

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

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

buf2.swap32();
// Throws ERR_INVALID_BUFFER_SIZE.

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

import { Buffer } from 'node:buffer';

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

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

buf1.swap64();

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

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

buf2.swap64();
// Throws ERR_INVALID_BUFFER_SIZE.

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32LE(0xfeedface, 0);

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeUInt32BE(0xfeedface, 0);

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt8(2, 0);
buf.writeInt8(-2, 1);

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16LE(0x0304, 0);

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(2);

buf.writeInt16BE(0x0102, 0);

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32LE(0x05060708, 0);

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeInt32BE(0x01020304, 0);

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatBE(0xcafebabe, 0);

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleLE(123.456, 0);

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(8);

buf.writeDoubleBE(123.456, 0);

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(5);

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

Идентичен buf.indexOf(), но находит последнее вхождение value, а не первое.

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

const buf1 = Buffer.allocUnsafe(26);

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

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

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

buf1[0] = 33;

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

Отрицательные индексы задают срез относительно конца buf, а не его начала.

import { Buffer } from 'node:buffer';

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(2);

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

Создает новый Buffer, используя переданные {data}

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5);

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(10);

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

buf.fill(0);

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

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

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

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

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

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

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

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

import { Buffer } from 'node:buffer';

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

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

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

    store.push(sb);
  }
});

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

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

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

import { Buffer } from 'node:buffer';

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

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

import { Buffer } from 'node:buffer';

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

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

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

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