bufferAllocators

Prefer modern Buffer allocation methods over the deprecated Buffer constructor.

✅ This rule is included in the node logical presets.

The new Buffer() constructor has been deprecated since Node.js 4 due to security and usability concerns. Modern alternatives provide safer and more explicit ways to create buffers.

Use Buffer.from() for creating a Buffer from existing data (strings, arrays, or ArrayBuffers). Use Buffer.alloc() for creating a Buffer of a specific size with zero-filled memory.

const 
const buffer: Buffer<ArrayBuffer>
buffer = new 
var Buffer: BufferConstructor
new (str: string, encoding?: BufferEncoding) => Buffer<ArrayBuffer> (+3 overloads)
Allocates a new buffer containing the given {str}.
@param ― str String to store in buffer.
@param ― encoding encoding to use, optional.  Default is 'utf8'
@deprecated ― since v10.0.0 - Use Buffer.from(string[, encoding]) instead.
Buffer("7468697320697320612074c3a97374", "hex");

const 
const buffer: Buffer<ArrayBuffer>
buffer = new 
var Buffer: BufferConstructor
new (array: ArrayLike<number>) => Buffer<ArrayBuffer> (+3 overloads)
Allocates a new buffer containing the given {array} of octets.
@param ― array The octets to store.
@deprecated ― since v10.0.0 - Use Buffer.from(array) instead.
Buffer([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);

const 
const buffer: Buffer<ArrayBuffer>
buffer = new 
var Buffer: BufferConstructor
new (size: number) => Buffer<ArrayBuffer> (+3 overloads)
Allocates a new buffer of {size} octets.
@param ― size count of octets to allocate.
@deprecated ― since v10.0.0 - Use Buffer.alloc() instead (also see Buffer.allocUnsafe()).
Buffer(10);

const 
const buffer: Buffer<ArrayBuffer>
buffer = 
var Buffer: BufferConstructor
Buffer.
BufferConstructor.from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer<ArrayBuffer> (+3 overloads)
Creates a new Buffer containing string. The encoding parameter identifies
the character encoding to be used when converting string into bytes.
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
A TypeError will be thrown if string is not a string or another type
appropriate for Buffer.from() variants.
Buffer.from(string) may also use the internal Buffer pool like
Buffer.allocUnsafe() does.
@since ― v5.10.0
@param ― string A string to encode.
@param ― encoding The encoding of string. Default: 'utf8'.
from("7468697320697320612074c3a97374", "hex");

const 
const buffer: Buffer<ArrayBuffer>
buffer = 
var Buffer: BufferConstructor
Buffer.
BufferConstructor.from(array: WithImplicitCoercion<ArrayLike<number>>): Buffer<ArrayBuffer> (+3 overloads)
Allocates a new Buffer using an array of bytes in the range 0 – 255.
Array entries outside that range will be truncated to fit into it.
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]);
If array is an Array-like object (that is, one with a length property of
type number), it is treated as if it is an array, unless it is a Buffer or
a Uint8Array. This means all other TypedArray variants get treated as an
Array. To create a Buffer from the bytes backing a TypedArray, use
Buffer.copyBytesFrom().
A TypeError will be thrown if array is not an Array or another type
appropriate for Buffer.from() variants.
Buffer.from(array) and Buffer.from(string) may also use the internal
Buffer pool like Buffer.allocUnsafe() does.
@since ― v5.10.0
from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);

const 
const buffer: Buffer<ArrayBuffer>
buffer = 
var Buffer: BufferConstructor
Buffer.
BufferConstructor.alloc(size: number, fill?: string | Uint8Array | number, encoding?: BufferEncoding): Buffer<ArrayBuffer>
Allocates a new Buffer of size bytes. If fill is undefined, theBuffer will be zero-filled.
import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5);

console.log(buf);
// Prints: <Buffer 00 00 00 00 00>
If size is larger than
constants.MAX_LENGTH
or smaller than 0, ERR_OUT_OF_RANGE is thrown.
If fill is specified, the allocated Buffer will be initialized by calling buf.fill(fill).
import { Buffer } from 'node:buffer';

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

console.log(buf);
// Prints: <Buffer 61 61 61 61 61>
If both fill and encoding are specified, the allocated Buffer will be
initialized by calling 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>
Calling Buffer.alloc() can be measurably slower than the alternative Buffer.allocUnsafe() but ensures that the newly created Buffer instance
contents will never contain sensitive data from previous allocations, including
data that might not have been allocated for Buffers.
A TypeError will be thrown if size is not a number.
@since ― v5.10.0
@param ― size The desired length of the new Buffer.
@param ― fill A value to pre-fill the new Buffer with.
@param ― encoding If fill is a string, this is its encoding.
alloc(10);

Options

This rule is not configurable.

When Not To Use It

If you are working with legacy code that specifically requires the old Buffer constructor (which is highly unlikely in modern codebases), you might choose not to enable this rule.

Equivalents in Other Linters

ESLint: unicorn/no-new-buffer
Oxlint: unicorn/no-new-buffer

Made with ❤️‍🔥 around the world by the Flint team and contributors.

bufferAllocators

Examples

Options

When Not To Use It

Further Reading

Equivalents in Other Linters