ArrayBuffer · TypedArray
· DataView

Creates a new ArrayBuffer of the given length, zero-initialized.

Parameters

• byteLength number — The size in bytes. Must be a non-negative integer. Maximum is implementation-defined (typically 2 GiB − 1 on 32-bit V8, larger on 64-bit).
• options.maxByteLength number optional — If provided, the buffer is resizable up to this length. Must be ≥ byteLength.

Returns

A new zero-filled ArrayBuffer of length byteLength.

Throws

• RangeError — if byteLength is negative or exceeds the implementation limit.
• RangeError — if maxByteLength < byteLength.
• TypeError — if called without new.

const ab = new ArrayBuffer(16);
console.log(ab.byteLength);
// 16

const resizable = new ArrayBuffer(8, { maxByteLength: 1024 });
console.log(resizable.resizable, resizable.maxByteLength);
// true 1024

Returns true if arg is a TypedArray or DataView (i.e. a view over some ArrayBuffer).

Parameters

• arg unknown — any value to test.

Returns

true if arg is a view (any TypedArray instance or a DataView). false otherwise — including for plain ArrayBuffer instances themselves.

Throws

Does not throw.

ArrayBuffer.isView(new Uint8Array(8));          // true
ArrayBuffer.isView(new DataView(new ArrayBuffer(8))); // true
ArrayBuffer.isView(new ArrayBuffer(8));         // false  (container, not view)
ArrayBuffer.isView([1, 2, 3]);                  // false
ArrayBuffer.isView(Buffer.from('a'));            // true   (Buffer extends Uint8Array)

The current size of the buffer in bytes.

Returns

A non-negative integer — the current byte length. For resizable buffers, this changes when resize() is called. For detached buffers, this is 0.

Throws

Does not throw. (Returns 0 after detach rather than throwing.)

const ab = new ArrayBuffer(32);
console.log(ab.byteLength);          // 32

const r = new ArrayBuffer(8, { maxByteLength: 64 });
r.resize(20);
console.log(r.byteLength);           // 20

const t = ab.transfer();
console.log(ab.byteLength);          // 0  (ab is now detached)

True if the buffer has been detached (its contents transferred or invalidated).

Returns

true after transfer or any operation that detaches the buffer; false otherwise.

Throws

Does not throw.

const ab = new ArrayBuffer(16);
console.log(ab.detached);            // false

const moved = ab.transfer();
console.log(ab.detached);            // true
console.log(moved.detached);         // false

new Uint8Array(ab)[0];               // TypeError: detached buffer

The upper bound on the buffer's size, set at construction. For non-resizable buffers, equals byteLength.

Returns

The maximum byte length the buffer can grow to via resize().

Throws

Does not throw.

const fixed = new ArrayBuffer(64);
console.log(fixed.maxByteLength);     // 64

const r = new ArrayBuffer(64, { maxByteLength: 4096 });
console.log(r.maxByteLength);         // 4096

True if this buffer was constructed as resizable (with a maxByteLength option), false otherwise.

Returns

true iff this buffer can be resized via resize().

Throws

Does not throw.

new ArrayBuffer(8).resizable;                            // false
new ArrayBuffer(8, { maxByteLength: 32 }).resizable;     // true

Changes the buffer's length to newByteLength. Only valid on resizable buffers.

Parameters

• newByteLength number — desired new length. Must be ≥ 0 and ≤ maxByteLength.

Returns

undefined.

Throws

• TypeError — if the buffer is not resizable.
• RangeError — if newByteLength is negative or exceeds maxByteLength.

const ab = new ArrayBuffer(8, { maxByteLength: 64 });
const tracker = new Uint8Array(ab);              // length-tracking
const fixed   = new Uint8Array(ab, 0, 8);        // fixed length

ab.resize(16);
console.log(tracker.length);                     // 16  — auto-tracked
console.log(fixed.length);                       // 8   — unchanged

ab.resize(4);
console.log(fixed.length);                       // 8   — but reads throw (out-of-bounds)

Returns a new ArrayBuffer containing a copy of the bytes from begin (inclusive) to end (exclusive).

Parameters

• begin number optional — start byte (inclusive). Defaults to 0. Negative counts from the end.
• end number optional — end byte (exclusive). Defaults to byteLength. Negative counts from the end.

Returns

A new ArrayBuffer of length end - begin containing a copy of those bytes. Independent backing memory.

Throws

• TypeError — if called on a detached buffer.

const ab = new ArrayBuffer(16);
new Uint8Array(ab).set([1,2,3,4,5,6,7,8]);

const part = ab.slice(2, 5);
console.log(part.byteLength);                // 3
console.log(new Uint8Array(part));           // Uint8Array(3) [3, 4, 5]

// independence — mutate part, original unchanged
new Uint8Array(part)[0] = 99;
console.log(new Uint8Array(ab)[2]);          // 3  — not affected

ab.slice(-4).byteLength;                     // 4  — last 4 bytes

Move the buffer's bytes into a new ArrayBuffer and detach the original. Optionally resize during the move.

Parameters

• newByteLength number optional — desired length of the new buffer. Defaults to current byteLength. Extra bytes (when growing) are zero-filled; bytes beyond (when shrinking) are dropped.

Returns

A new ArrayBuffer with the same bytes (resized if requested). The new buffer is resizable if the original was; its maxByteLength equals the original's. The original buffer becomes detached.

Throws

• TypeError — if the original is already detached.
• RangeError — if newByteLength exceeds maxByteLength.

const ab = new ArrayBuffer(16);
new Uint8Array(ab)[0] = 0xFF;

const moved = ab.transfer();
console.log(moved.byteLength);            // 16
console.log(new Uint8Array(moved)[0]);    // 0xFF — bytes preserved
console.log(ab.detached);                 // true
console.log(ab.byteLength);               // 0

// resize during transfer
const grown = moved.transfer(32);
console.log(grown.byteLength);            // 32 (extra bytes are zero)

Like transfer, but the new buffer is always non-resizable, regardless of the source.

Parameters

• newByteLength number optional — same as transfer.

Returns

A new fixed-length ArrayBuffer. The original is detached.

Throws

Same as transfer.

const r = new ArrayBuffer(16, { maxByteLength: 1024 });
const locked = r.transferToFixedLength();
console.log(locked.resizable);           // false
console.log(locked.byteLength);          // 16
console.log(r.detached);                 // true

Returns the constructor to be used for derived buffers. By default, returns ArrayBuffer itself.

Returns

By default, the ArrayBuffer constructor.

Throws

Does not throw.

console.log(ArrayBuffer[Symbol.species] === ArrayBuffer);  // true

// Subclassing override (legacy pattern):
class TaggedAB extends ArrayBuffer {
  static get [Symbol.species]() { return ArrayBuffer; }
}

The tag used by Object.prototype.toString to produce "[object ArrayBuffer]".

Returns

The literal string "ArrayBuffer".

Throws

Does not throw.

Object.prototype.toString.call(new ArrayBuffer(0));   // "[object ArrayBuffer]"
ArrayBuffer.prototype[Symbol.toStringTag];            // "ArrayBuffer"