Буфер

До появления TypedArray в ECMAScript 2015 (ES6) в языке JavaScript не было механизма для чтения или обработки потоков двоичных данных. Класс Buffer был добавлен в API Node.js для возможности взаимодействия с потоками байтов, например, с TCP-потоками и операциями с файловой системой.

Теперь, когда TypedArray добавлен в ES6, класс Buffer реализует API Uint8Array более оптимизированным и подходящим для использования в Node.js способом.

Экземпляры класса Buffer похожи на массивы целых чисел, но соответствуют фиксированным выделениям памяти размером вне кучи V8. Размер буфера Buffer устанавливается при его создании и не может быть изменён.

Класс Buffer является глобальным в Node.js, поэтому маловероятно, что потребуется использовать require('buffer').Buffer.

const buf1 = new Buffer(10);
  // creates a buffer of length 10
  // This is the same as Buffer.allocUnsafe(10), and the returned
  // Buffer instance might contain old data that needs to be
  // overwritten using either fill() or write().

const buf2 = new Buffer([1,2,3]);
  // creates a buffer containing [01, 02, 03]
  // This is the same as Buffer.from([1,2,3]).

const buf3 = new Buffer('test');
  // creates a buffer containing ASCII bytes [74, 65, 73, 74]
  // This is the same as Buffer.from('test').

const buf4 = new Buffer('tést', 'utf8');
  // creates a buffer containing UTF8 bytes [74, c3, a9, 73, 74]
  // This is the same as Buffer.from('tést', 'utf8').

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

const buf6 = Buffer.alloc(10, 1);
  // Creates a Buffer of length 10, filled with 0x01.

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

const buf8 = Buffer.from([1,2,3]);
  // Creates a Buffer containing [01, 02, 03].

const buf9 = Buffer.from('test');
  // Creates a Buffer containing ASCII bytes [74, 65, 73, 74].

const buf8 = Buffer.from('tést', 'utf8');
  // Creates a Buffer containing UTF8 bytes [74, c3, a9, 73, 74].

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

Исторически экземпляры Buffer создавались с помощью конструктора Buffer, который выделяет возвращаемый буфер Buffer по-разному в зависимости от переданных аргументов:

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

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

Чтобы сделать создание объектов Buffer более надёжным и менее подверженным ошибкам, были введены новые методы Buffer.from(), Buffer.alloc(), и Buffer.allocUnsafe() как альтернативный способ создания экземпляров Buffer.

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

• Buffer.from(array) возвращает новый буфер Buffer, содержащий копию переданных байтов.
• Buffer.from(arrayBuffer) возвращает новый буфер Buffer, который разделяет ту же выделенную память, что и заданный объект ArrayBuffer.
• Buffer.from(buffer) возвращает новый буфер Buffer, содержащий копию содержимого заданного буфера Buffer.
• Buffer.from(str[, encoding]) возвращает новый буфер Buffer, содержащий копию переданной строки.
• Buffer.alloc(size[, fill[, encoding]]) возвращает экземпляр «заполненного» буфера Buffer заданного размера. Этот метод может быть значительно медленнее, чем Buffer.allocUnsafe(size), но гарантирует, что вновь созданные буферы Buffer никогда не содержат старых, потенциально конфиденциальных данных.
• Buffer.allocUnsafe(size) и Buffer.allocUnsafeSlow(size) каждый возвращает новый буфер Buffer заданного размера size, чьё содержимое необходимо инициализировать, используя либо buf.fill(0), либо полностью записав в него данные.

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

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

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

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

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

Буферы часто используются для представления последовательностей закодированных символов, таких как UTF8, UCS2, Base64 или даже шестнадцатеричные данные. Возможна конвертация между буферами и обычными строками JavaScript с помощью явного метода кодирования.

const buf = new Buffer('hello world', 'ascii');
console.log(buf.toString('hex'));
  // prints: 68656c6c6f20776f726c64
console.log(buf.toString('base64'));
  // prints: aGVsbG8gd29ybGQ=

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

• 'ascii' — только для 7-битных данных ASCII. Этот метод кодирования очень быстрый и удалит установленный старший бит.

• 'utf8' — многобайтовые закодированные символы Unicode. Многие веб-страницы и другие форматы документов используют UTF-8.

• 'utf16le' — 2 или 4 байта, закодированные символы Unicode в формате little-endian. Поддерживаются пары суррогатов (U+10000 до U+10FFFF).

• 'ucs2' — псевдоним для 'utf16le'.

• 'base64' — кодирование строки в формате Base64. При создании буфера из строки эта кодировка также корректно примет «URL и Filename Safe Alphabet», как указано в RFC 4648, раздел 5.

• 'binary' — способ кодирования буфера в строку с однобайтовым (latin-1) кодированием. Строка 'latin-1' не поддерживается. Вместо этого передайте 'binary' для использования кодировки 'latin-1'.

• 'hex' — каждый байт кодируется двумя шестнадцатеричными символами.

Буферы и TypedArray

Буферы также являются экземплярами Uint8Array TypedArray. Однако существуют неявные несовместимости со спецификацией TypedArray в ECMAScript 2015. Например, в то время как ArrayBuffer#slice() создаёт копию среза, реализация Buffer#slice() создаёт представление над существующим буфером без копирования, что делает Buffer#slice() намного эффективнее.

Также возможно создание новых экземпляров TypedArray из буфера Buffer с учётом следующих замечаний:

1. Память буфера копируется в TypedArray, а не делится.

2. Память буфера интерпретируется как массив отдельных элементов, а не как массив байтов целевого типа. То есть, new Uint32Array(new Buffer([1,2,3,4])) создаёт Uint32Array из 4 элементов с элементами [1,2,3,4], а не Uint32Array с одним элементом [0x1020304] или [0x4030201].

Можно создать новый буфер, который разделяет выделенную память с экземпляром TypedArray, используя свойство TypeArray objects .buffer:

const arr = new Uint16Array(2);
arr[0] = 5000;
arr[1] = 4000;

const buf1 = new Buffer(arr); // copies the buffer
const buf2 = new Buffer(arr.buffer); // shares the memory with arr;

console.log(buf1);
  // Prints: <Buffer 88 a0>, copied buffer has only two elements
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 свойства TypeArray в настоящее время невозможно использовать только часть базового ArrayBuffer. Чтобы создать буфер, использующий только часть ArrayBuffer, используйте функцию buf.slice() после создания буфера:

const arr = new Uint16Array(20);
const buf = new Buffer(arr.buffer).slice(0, 16);
console.log(buf.length);
  // Prints: 16

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

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

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

• Buffer.from(array)
• Buffer.from(buffer)
• Buffer.from(arrayBuffer)
• Buffer.from(str[, encoding])

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

Буферы могут быть итерированы с помощью синтаксиса ECMAScript 2015 (ES6) for..of:

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

for (var b of buf)
  console.log(b)

// Prints:
//   1
//   2
//   3

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

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

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

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

Класс: Buffer

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

new Buffer(array)

Создаёт новый буфер, используя array байтов.

const buf = new Buffer([0x62,0x75,0x66,0x66,0x65,0x72]);
  // creates a new Buffer containing ASCII bytes
  // ['b','u','f','f','e','r']

new Buffer(buffer)

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

const buf1 = new Buffer('buffer');
const buf2 = new Buffer(buf1);

buf1[0] = 0x61;
console.log(buf1.toString());
  // 'auffer'
console.log(buf2.toString());
  // 'buffer' (copy is not changed)

new Buffer(arrayBuffer)

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

const arr = new Uint16Array(2);
arr[0] = 5000;
arr[1] = 4000;

const buf = new Buffer(arr.buffer); // shares the memory with arr;

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

// changing the TypdArray changes the Buffer also
arr[1] = 6000;

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

new Buffer(size)

Выделяет новый буфер размером в size байт. Размер size должен быть меньше или равен значению require('buffer').kMaxLength (на 64-битных архитектурах, kMaxLength равно (2^31)-1). В противном случае выбрасывается RangeError. Если указан размер size меньше 0, будет создан буфер длиной 0.

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

const buf = new Buffer(5);
console.log(buf);
  // <Buffer 78 e0 82 02 01>
  // (octets will be different, every time)
buf.fill(0);
console.log(buf);
  // <Buffer 00 00 00 00 00>

new Buffer(str[, encoding])

Создаёт новый буфер, содержащий заданную JavaScript строку str. Если указан параметр encoding, он определяет кодировку символов строки.

const buf1 = new Buffer('this is a tést');
console.log(buf1.toString());
  // prints: this is a tést
console.log(buf1.toString('ascii'));
  // prints: this is a tC)st

const buf2 = new Buffer('7468697320697320612074c3a97374', 'hex');
console.log(buf2.toString());
  // prints: this is a tést

Классный метод: Buffer.alloc(size[, fill[, encoding]])

• size <Число>
• fill <Значение> По умолчанию: undefined
• encoding <Строка> По умолчанию: utf8

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

const buf = Buffer.alloc(5);
console.log(buf);
  // <Buffer 00 00 00 00 00>

Размер size должен быть меньше или равен значению require('buffer').kMaxLength (на 64-битных архитектурах, kMaxLength равно (2^31)-1). В противном случае выбрасывается RangeError. Если размер size меньше 0, будет создан буфер длиной 0.

Если fill задан, выделенный Buffer будет инициализирован с помощью buf.fill(fill). См. [buf.fill()][] для получения дополнительной информации.

const buf = Buffer.alloc(5, 'a');
console.log(buf);
  // <Buffer 61 61 61 61 61>

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

const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
console.log(buf);
  // <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>

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

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

Классный метод: Buffer.allocUnsafe(size)

• size <Число>

Выделяет новый не заполненный нулями Buffer размером в size байт. Размер size должен быть меньше или равен значению require('buffer').kMaxLength (на 64-битных архитектурах, kMaxLength равно (2^31)-1). В противном случае выбрасывается RangeError. Если размер size меньше 0, будет создан буфер длиной 0.

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

const buf = Buffer.allocUnsafe(5);
console.log(buf);
  // <Buffer 78 e0 82 02 01>
  // (octets will be different, every time)
buf.fill(0);
console.log(buf);
  // <Buffer 00 00 00 00 00>

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

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

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

Классный метод: Buffer.allocUnsafeSlow(size)

• size <Число>

Выделяет новый не заполненный нулями и не из пула Buffer размером в size байт. Размер size должен быть меньше или равен значению require('buffer').kMaxLength (на 64-битных архитектурах, kMaxLength равно (2^31)-1). В противном случае выбрасывается RangeError. Если размер size меньше 0, будет создан буфер длиной 0.

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

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

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

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

socket.on('readable', () => {
  const data = socket.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);
});

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

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

Классный метод: Buffer.byteLength(string[, encoding])

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

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

Пример:

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

console.log(`${str}: ${str.length} characters, ` +
            `${Buffer.byteLength(str, 'utf8')} bytes`);

// ½ + ¼ = ¾: 9 characters, 12 bytes

Классный метод: Buffer.compare(buf1, buf2)

• buf1 <Буфер>
• buf2 <Буфер>
• Возвращает: <Число>

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

const arr = [Buffer('1234'), Buffer('0123')];
arr.sort(Buffer.compare);

Классный метод: Buffer.concat(list[, totalLength])

• list <Массив> Список объектов Buffer для конкатенации
• totalLength <Число> Общая длина объединённых объектов Buffer в списке
• Возвращает: <Buffer>

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

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

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

Пример: создание одного Buffer из списка из трёх Buffer:

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

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

// 42
// <Buffer 00 00 00 00 ...>
// 42

Метод класса: Buffer.from(array)

• array <Массив>

Выделяет новый Buffer, используя array байтов.

const buf = Buffer.from([0x62,0x75,0x66,0x66,0x65,0x72]);
  // creates a new Buffer containing ASCII bytes
  // ['b','u','f','f','e','r']

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

Метод класса: Buffer.from(arrayBuffer)

• arrayBuffer <ArrayBuffer> Свойство .buffer объекта TypedArray или new ArrayBuffer()

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

const arr = new Uint16Array(2);
arr[0] = 5000;
arr[1] = 4000;

const buf = Buffer.from(arr.buffer); // shares the memory with arr;

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

// changing the TypedArray changes the Buffer also
arr[1] = 6000;

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

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

Метод класса: Buffer.from(buffer)

• buffer <Buffer>

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

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

buf1[0] = 0x61;
console.log(buf1.toString());
  // 'auffer'
console.log(buf2.toString());
  // 'buffer' (copy is not changed)

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

Метод класса: Buffer.from(str[, encoding])

• str <Строка> Строка для кодирования.
• encoding <Строка> Используемая кодировка, По умолчанию: 'utf8'

Создаёт новый Buffer, содержащий заданную строку JavaScript str. Если параметр encoding предоставлен, он определяет кодировку символов. Если он не предоставлен, encoding по умолчанию 'utf8'.

const buf1 = Buffer.from('this is a tést');
console.log(buf1.toString());
  // prints: this is a tést
console.log(buf1.toString('ascii'));
  // prints: this is a tC)st

const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
console.log(buf2.toString());
  // prints: this is a tést

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

Метод класса: Buffer.isBuffer(obj)

Возвращает 'true', если obj является Buffer.

Метод класса: Buffer.isEncoding(encoding)

• encoding <Строка> Строка кодировки для проверки
• Возвращает: <Булево>

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

buf[index]

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

Пример: копирование ASCII строки в Buffer, по одному байту за раз:

const str = "Node.js";
const buf = new Buffer(str.length);

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

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

buf.compare(otherBuffer)

• otherBuffer <Buffer>
• Возвращает: <Число>

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

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

const buf1 = new Buffer('ABC');
const buf2 = new Buffer('BCD');
const buf3 = new Buffer('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

[buf1, buf2, buf3].sort(Buffer.compare);
  // produces sort order [buf1, buf3, buf2]

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

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

Пример: создать два Buffer, затем скопировать buf1 с байта 16 по байт 19 в buf2, начиная с 8-го байта в buf2.

const buf1 = new Buffer(26);
const buf2 = new Buffer(26).fill('!');

for (var i = 0 ; i < 26 ; i++) {
  buf1[i] = i + 97; // 97 is ASCII a
}

buf1.copy(buf2, 8, 16, 20);
console.log(buf2.toString('ascii', 0, 25));
  // Prints: !!!!!!!!qrst!!!!!!!!!!!!!

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

const buf = new Buffer(26);

for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97; // 97 is ASCII a
}

buf.copy(buf, 0, 4, 10);
console.log(buf.toString());

// efghijghijklmnopqrstuvwxyz

buf.entries()

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

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

const buf = new Buffer('buffer');
for (var 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>
• Возвращает: <Булево>

Возвращает boolean, указывающий, имеют ли this и otherBuffer точно такие же байты.

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

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

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

• value <Строка> | <Число>
• offset <Число> По умолчанию: 0
• end <Число> По умолчанию: buffer.length
• Возвращает: <Buffer>

Заполняет Buffer указанным значением. Если offset и end не указаны, заполняется весь Buffer. Метод возвращает ссылку на Buffer, позволяя цепочку вызовов.

const b = new Buffer(50).fill('h');
console.log(b.toString());
  // Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

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

• value <Строка> | <Buffer> | <Число>
• byteOffset <Число> По умолчанию: 0
• encoding <Строка> По умолчанию: 'utf8'
• Возвращает: <Число>

Действует аналогично Array#indexOf(), возвращая либо начальную позицию индекса value в Buffer, либо -1, если Buffer не содержит value. value может быть строкой, Buffer или числом. Строки по умолчанию интерпретируются как UTF8. Buffers будут использовать весь Buffer (для сравнения частичного Buffer используйте buf.slice()). Числа будут интерпретироваться как целые беззнаковые 8-битные значения между 0 и 255.

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

buf.indexOf('this');
  // returns 0
buf.indexOf('is');
  // returns 2
buf.indexOf(new Buffer('a buffer'));
  // returns 8
buf.indexOf(97); // ascii for 'a'
  // returns 8
buf.indexOf(new Buffer('a buffer example'));
  // returns -1
buf.indexOf(new Buffer('a buffer example').slice(0,8));
  // returns 8

const utf16Buffer = new Buffer('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');

utf16Buffer.indexOf('\u03a3',  0, 'ucs2');
  // returns 4
utf16Buffer.indexOf('\u03a3', -4, 'ucs2');
  // returns 6

buf.keys()

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

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

const buf = new Buffer('buffer');
for (var key of buf.keys()) {
  console.log(key);
}
// prints:
//   0
//   1
//   2
//   3
//   4
//   5

buf.length

Возвращает количество выделенной памяти для Buffer в байтах. Обратите внимание, что это не обязательно отражает количество используемых данных в Buffer. Например, в примере ниже выделен Buffer размером 1234 байта, но записано только 11 ASCII байтов.

const buf = new Buffer(1234);

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

buf.write('some string', 0, 'ascii');
console.log(buf.length);
  // Prints: 1234

Хотя свойство length не является неизменяемым, изменение значения length может привести к неопределённому и несогласованному поведению. Поэтому приложения, которые хотят изменить длину Buffer, должны рассматривать length как только для чтения и использовать buf.slice() для создания нового Buffer.

var buf = new Buffer(10);
buf.write('abcdefghj', 0, 'ascii');
console.log(buf.length);
  // Prints: 10
buf = buf.slice(0,5);
console.log(buf.length);
  // Prints: 5

buf.readDoubleBE(offset[, noAssert])

buf.readDoubleLE(offset[, noAssert])

Читает 64-битное значение типа double из Buffer по указанному offset с указанным порядком байтов (readDoubleBE() возвращает порядок байтов big-endian, readDoubleLE() возвращает little-endian).

Установление noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами конца Buffer.

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

buf.readDoubleBE();
  // Returns: 8.20788039913184e-304
buf.readDoubleLE();
  // Returns: 5.447603722011605e-270
buf.readDoubleLE(1);
  // throws RangeError: Index out of range

buf.readDoubleLE(1, true); // Warning: reads passed end of buffer!
  // Segmentation fault! don't do this!

buf.readFloatBE(offset[, noAssert])

buf.readFloatLE(offset[, noAssert])

Читает 32-битное значение типа float из Buffer по указанному offset с указанным порядком байтов (readFloatBE() возвращает big endian, readFloatLE() возвращает little endian).

Установление noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами конца Buffer.

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

buf.readFloatBE();
  // Returns: 2.387939260590663e-38
buf.readFloatLE();
  // Returns: 1.539989614439558e-36
buf.readFloatLE(1);
  // throws RangeError: Index out of range

buf.readFloatLE(1, true); // Warning: reads passed end of buffer!
  // Segmentation fault! don't do this!

buf.readInt8(offset[, noAssert])

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

Установление noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами конца Buffer.

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

const buf = new Buffer([1,-2,3,4]);

buf.readInt8(0);
  // returns 1
buf.readInt8(1);
  // returns -2

buf.readInt16BE(offset[, noAssert])

buf.readInt16LE(offset[, noAssert])

Читает знаковое 16-битное целое число из Buffer по указанному offset с указанным порядком байтов (readInt16BE() возвращает big endian, readInt16LE() возвращает little endian).

Установление noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами конца Buffer.

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

const buf = new Buffer([1,-2,3,4]);

buf.readInt16BE();
  // returns 510
buf.readInt16LE(1);
  // returns 1022

buf.readInt32BE(offset[, noAssert])

buf.readInt32LE(offset[, noAssert])

Читает знаковое 32-битное целое число из Buffer по указанному offset с указанным порядком байтов (readInt32BE() возвращает big endian, readInt32LE() возвращает little endian).

Установление noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами конца Buffer.

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

const buf = new Buffer([1,-2,3,4]);

buf.readInt32BE();
  // returns 33424132
buf.readInt32LE();
  // returns 67370497
buf.readInt32LE(1);
  // throws RangeError: Index out of range

buf.readIntBE(offset, byteLength[, noAssert])

buf.readIntLE(offset, byteLength[, noAssert])

• offset <Число> 0 <= offset <= buf.length - byteLength
• byteLength <Число> 0 < byteLength <= 6
• noAssert <Булево> Значение по умолчанию: false
• Возвращает: <Число>

Читает byteLength байтов из Buffer по указанному offset и интерпретирует результат как знаковое значение в дополнительном коде. Поддерживает точность до 48 бит. Например:

const buf = new Buffer(6);
buf.writeUInt16LE(0x90ab, 0);
buf.writeUInt32LE(0x12345678, 2);
buf.readIntLE(0, 6).toString(16);  // Specify 6 bytes (48 bits)
// Returns: '1234567890ab'

buf.readIntBE(0, 6).toString(16);
// Returns: -546f87a9cbee

Установление noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами конца Buffer.

buf.readUInt8(offset[, noAssert])

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

Установление noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами конца Buffer.

const buf = new Buffer([1,-2,3,4]);

buf.readUInt8(0);
  // returns 1
buf.readUInt8(1);
  // returns 254

buf.readUInt16BE(offset[, noAssert])

buf.readUInt16LE(offset[, noAssert])

Читает беззнаковое 16-битное целое число из Buffer по указанному offset с указанным порядком байтов (readUInt16BE() возвращает big endian, readUInt16LE() возвращает little endian).

Установление noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами конца Buffer.

Пример:

const buf = new Buffer([0x3, 0x4, 0x23, 0x42]);

buf.readUInt16BE(0);
  // Returns: 0x0304
buf.readUInt16LE(0);
  // Returns: 0x0403
buf.readUInt16BE(1);
  // Returns: 0x0423
buf.readUInt16LE(1);
  // Returns: 0x2304
buf.readUInt16BE(2);
  // Returns: 0x2342
buf.readUInt16LE(2);
  // Returns: 0x4223

buf.readUInt32BE(offset[, noAssert])

buf.readUInt32LE(offset[, noAssert])

Читает целое беззнаковое 32-битное число из буфера по указанному offset с указанным форматом порядка байтов (readUInt32BE() возвращает порядок байтов big endian, readUInt32LE() возвращает little endian).

Установка noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами буфера.

Пример:

const buf = new Buffer([0x3, 0x4, 0x23, 0x42]);

buf.readUInt32BE(0);
  // Returns: 0x03042342
console.log(buf.readUInt32LE(0));
  // Returns: 0x42230403

buf.readUIntBE(offset, byteLength[, noAssert])

buf.readUIntLE(offset, byteLength[, noAssert])

• offset <Число> 0 <= offset <= buf.length - byteLength
• byteLength <Число> 0 < byteLength <= 6
• noAssert <Булево> По умолчанию: false
• Возвращает: <Число>

Читает byteLength байт из буфера по указанному offset и интерпретирует результат как целое беззнаковое число. Поддерживает точность до 48 бит. Например:

const buf = new Buffer(6);
buf.writeUInt16LE(0x90ab, 0);
buf.writeUInt32LE(0x12345678, 2);
buf.readUIntLE(0, 6).toString(16);  // Specify 6 bytes (48 bits)
// Returns: '1234567890ab'

buf.readUIntBE(0, 6).toString(16);
// Returns: ab9078563412

Установка noAssert в true пропускает проверку offset. Это позволяет offset находиться за пределами буфера.

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

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

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

Пример: создать буфер с ASCII алфавитом, взять срез, затем изменить один байт в исходном буфере.

const buf1 = new Buffer(26);

for (var i = 0 ; i < 26 ; i++) {
  buf1[i] = i + 97; // 97 is ASCII a
}

const buf2 = buf1.slice(0, 3);
buf2.toString('ascii', 0, buf2.length);
  // Returns: 'abc'
buf1[0] = 33;
buf2.toString('ascii', 0, buf2.length);
  // Returns : '!bc'

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

const buf = new Buffer('buffer');

buf.slice(-6, -1).toString();
  // Returns 'buffe', equivalent to buf.slice(0, 5)
buf.slice(-6, -2).toString();
  // Returns 'buff', equivalent to buf.slice(0, 4)
buf.slice(-5, -2).toString();
  // Returns 'uff', equivalent to buf.slice(1, 4)

buf.toString([encoding[, start[, end]]])

Декодирует и возвращает строку из данных буфера с использованием указанного набора символов encoding.

const buf = new Buffer(26);
for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97; // 97 is ASCII a
}
buf.toString('ascii');
  // Returns: 'abcdefghijklmnopqrstuvwxyz'
buf.toString('ascii',0,5);
  // Returns: 'abcde'
buf.toString('utf8',0,5);
  // Returns: 'abcde'
buf.toString(undefined,0,5);
  // Returns: 'abcde', encoding defaults to 'utf8'

buf.toJSON()

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

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

Пример:

const buf = new Buffer('test');
const json = JSON.stringify(buf);

console.log(json);
// Prints: '{"type":"Buffer","data":[116,101,115,116]}'

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

console.log(copy.toString());
// Prints: 'test'

buf.values()

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

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

const buf = new Buffer('buffer');
for (var value of buf.values()) {
  console.log(value);
}
// prints:
//   98
//   117
//   102
//   102
//   101
//   114

for (var value of buf) {
  console.log(value);
}
// prints:
//   98
//   117
//   102
//   102
//   101
//   114

buf.write(string[, offset[, length]][, encoding])

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

const buf = new Buffer(256);
const len = buf.write('\u00bd + \u00bc = \u00be', 0);
console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`);
  // Prints: 12 bytes: ½ + ¼ = ¾

buf.writeDoubleBE(value, offset[, noAssert])

buf.writeDoubleLE(value, offset[, noAssert])

Записывает value в буфер по указанному offset с указанным форматом порядка байтов (writeDoubleBE() записывает big endian, writeDoubleLE() записывает little endian). Аргумент value должен быть корректным 64-битным double. Поведение не определено, если value не является 64-битным double.

Установите noAssert в true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, и offset может быть за пределами буфера, что приведёт к тому, что значения будут проигнорированы. Это следует использовать только в случае уверенности в корректности.

Пример:

const buf = new Buffer(8);
buf.writeDoubleBE(0xdeadbeefcafebabe, 0);

console.log(buf);
  // Prints: <Buffer 43 eb d5 b7 dd f9 5f d7>

buf.writeDoubleLE(0xdeadbeefcafebabe, 0);

console.log(buf);
  // Prints: <Buffer d7 5f f9 dd b7 d5 eb 43>

buf.writeFloatBE(value, offset[, noAssert])

buf.writeFloatLE(value, offset[, noAssert])

Записывает value в буфер по указанному offset с указанным форматом порядка байтов (writeFloatBE() записывает big endian, writeFloatLE() записывает little endian). Поведение не определено, если value не является 32-битным float.

Установите noAssert в true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, и offset может быть за пределами буфера, что приведёт к тому, что значения будут проигнорированы. Это следует использовать только в случае уверенности в корректности.

Пример:

const buf = new Buffer(4);
buf.writeFloatBE(0xcafebabe, 0);

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

buf.writeFloatLE(0xcafebabe, 0);

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

buf.writeInt8(value, offset[, noAssert])

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

Установите noAssert в значение true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, а offset может выходить за пределы буфера, что приведёт к игнорированию значений. Не используйте этот вариант, если не уверены в корректности данных.

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

const buf = new Buffer(2);
buf.writeInt8(2, 0);
buf.writeInt8(-2, 1);
console.log(buf);
  // Prints: <Buffer 02 fe>

buf.writeInt16BE(value, offset[, noAssert])

buf.writeInt16LE(value, offset[, noAssert])

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

Установите noAssert в значение true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, а offset может выходить за пределы буфера, что приведёт к игнорированию значений. Не используйте этот вариант, если не уверены в корректности данных.

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

const buf = new Buffer(4);
buf.writeInt16BE(0x0102,0);
buf.writeInt16LE(0x0304,2);
console.log(buf);
  // Prints: <Buffer 01 02 04 03>

buf.writeInt32BE(value, offset[, noAssert])

buf.writeInt32LE(value, offset[, noAssert])

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

Установите noAssert в значение true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, а offset может выходить за пределы буфера, что приведёт к игнорированию значений. Не используйте этот вариант, если не уверены в корректности данных.

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

const buf = new Buffer(8);
buf.writeInt32BE(0x01020304,0);
buf.writeInt32LE(0x05060708,4);
console.log(buf);
  // Prints: <Buffer 01 02 03 04 08 07 06 05>

buf.writeIntBE(value, offset, byteLength[, noAssert])

buf.writeIntLE(value, offset, byteLength[, noAssert])

• value <Число> Байты, которые будут записаны в буфер
• offset <Число> 0 <= offset <= buf.length - byteLength
• byteLength <Число> 0 < byteLength <= 6
• noAssert <Булево> По умолчанию: false
• Возвращает: <Число> Смещение плюс количество записанных байтов

Записывает value в буфер по указанному offset и byteLength. Поддерживает точность до 48 бит. Например:

const buf1 = new Buffer(6);
buf1.writeUIntBE(0x1234567890ab, 0, 6);
console.log(buf1);
  // Prints: <Buffer 12 34 56 78 90 ab>

const buf2 = new Buffer(6);
buf2.writeUIntLE(0x1234567890ab, 0, 6);
console.log(buf2);
  // Prints: <Buffer ab 90 78 56 34 12>

Установите noAssert в значение true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, а offset может выходить за пределы буфера, что приведёт к игнорированию значений. Не используйте этот вариант, если не уверены в корректности данных.

Поведение не определено, если value не является целым числом.

buf.writeUInt8(value, offset[, noAssert])

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

Установите noAssert в значение true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, а offset может выходить за пределы буфера, что приведёт к игнорированию значений. Не используйте этот вариант, если не уверены в корректности данных.

Пример:

const buf = new Buffer(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[, noAssert])

buf.writeUInt16LE(value, offset[, noAssert])

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

Установите noAssert в значение true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, а offset может выходить за пределы буфера, что приведёт к игнорированию значений. Не используйте этот вариант, если не уверены в корректности данных.

Пример:

const buf = new Buffer(4);
buf.writeUInt16BE(0xdead, 0);
buf.writeUInt16BE(0xbeef, 2);

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

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

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

buf.writeUInt32BE(value, offset[, noAssert])

buf.writeUInt32LE(value, offset[, noAssert])

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

Установите noAssert в значение true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, а offset может выходить за пределы буфера, что приведёт к игнорированию значений. Не используйте этот вариант, если не уверены в корректности данных.

Пример:

const buf = new Buffer(4);
buf.writeUInt32BE(0xfeedface, 0);

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

buf.writeUInt32LE(0xfeedface, 0);

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

buf.writeUIntBE(value, offset, byteLength[, noAssert])

buf.writeUIntLE(value, offset, byteLength[, noAssert])

Записывает value в буфер по указанному offset и byteLength. Поддерживает точность до 48 бит. Например:

const buf = new Buffer(6);
buf.writeUIntBE(0x1234567890ab, 0, 6);
console.log(buf);
  // Prints: <Buffer 12 34 56 78 90 ab>

Установите noAssert в значение true, чтобы пропустить проверку value и offset. Это означает, что value может быть слишком большим для конкретной функции, а offset может выходить за пределы буфера, что приведёт к тому, что значения будут отброшены без сообщений об ошибках. Это следует использовать только в том случае, если вы уверены в правильности данных.

Поведение не определено, когда value является чем-либо, кроме беззнакового целого числа.

buffer.INSPECT_MAX_BYTES

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

Обратите внимание, что это свойство модуля buffer, возвращаемого require('buffer'), а не глобального буфера или экземпляра Buffer.

Класс: SlowBuffer

Возвращает не-пулированный Buffer.

Для избежания накладных расходов на сборку мусора при создании многих отдельных выделенных буферов по умолчанию выделения размером менее 4 КБ извлекаются из одного большего выделенного объекта. Этот подход улучшает как производительность, так и использование памяти, так как v8 не нужно отслеживать и очищать столько объектов Persistent.

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

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

socket.on('readable', () => {
  var data = socket.read();
  // allocate for retained data
  var sb = new SlowBuffer(10);
  // copy the data into the new allocation
  data.copy(sb, 0, 0, 10);
  store.push(sb);
});

Использование SlowBuffer следует применять только в крайних случаях после того, как разработчик наблюдал чрезмерное удержание памяти в своих приложениях.

new SlowBuffer(size)

Выделяет новый SlowBuffer размером size байтов. Размер size должен быть меньше или равен значению require('buffer').kMaxLength (на 64-битных архитектурах, kMaxLength равно (2^31)-1). В противном случае будет выброшено исключение RangeError. Если задан размер size меньше 0, будет создан буфер нулевой длины.

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

const SlowBuffer = require('buffer').SlowBuffer;
const buf = new SlowBuffer(5);
console.log(buf);
  // <Buffer 78 e0 82 02 01>
  // (octets will be different, every time)
buf.fill(0);
console.log(buf);
  // <Buffer 00 00 00 00 00>