Fast arrays & elements kinds

Arrays have element storage

JavaScript arrays look flexible: you can put numbers, strings, objects, and missing indexes in one value. Engines still try to keep the common case fast. V8 stores numeric indexes separately from named properties, then labels that indexed storage with an elements kind.

The language still says an array is an object whose indexes are property keys. The engine strategy is extra. You can observe it only with V8-only probes such as %HasSmiElements and %DebugPrint, not from normal web code.

This lesson follows the V8 team's Elements kinds in V8 article. It links sideways to array basics, iterating arrays, and typed arrays for language-level behavior. The previous hidden classes lesson covers named properties; this one covers indexed elements.

Packed arrays and holes

Packed means every index from 0 to length - 1 is present. Holey means at least one of those indexes is missing. A missing index is called a hole. It is not the same as a present value whose value happens to be undefined.

1const packed = ["Asha", "Ravi", "Meera"];2const holey = new Array(3);3holey[1] = "Ravi";4 5console.log(0 in packed);6console.log(0 in holey);7console.log(holey.length);

Line 1 creates three present indexes. Line 2 creates a length without values, so the slots are holes. Line 3 fills only index 1. That is why line 6 prints false: index 0 is missing, even though the array's length is 3.

Packed operations can skip some checks. Holey operations must ask, “is the value really present here, or should I look on the prototype chain?” Once V8 marks an array holey, filling the visible holes later does not make it packed again in the normal transition lattice.

Smi, double, and generic elements

V8 uses Smi for small integers that fit directly in a tagged value. In official Node 22 builds on 64-bit machines, pointer compression is off, so the Smi range includes 2 ** 31 - 1. Chrome builds commonly use pointer compression, where the exact range differs. Treat that number as V8-build-specific, not JavaScript semantics.

1const counts = [1, 2, 3];2counts.push(-0);3counts.push(NaN);4counts.push(Infinity);5 6console.log(Object.is(counts[3], -0));7console.log(Number.isNaN(counts[4]));8console.log(counts[5] === Infinity);

Line 2 pushes -0. JavaScript can distinguish -0 from +0 with Object.is, so V8 cannot store it as a Smi. Lines 3 and 4 add NaN and Infinity; both are double values too.

1function label(array) {2  if (%HasDictionaryElements(array)) return "DICTIONARY_ELEMENTS";3  const prefix = %HasHoleyElements(array) ? "HOLEY" : "PACKED";4  if (%HasSmiElements(array)) return prefix + "_SMI_ELEMENTS";5  if (%HasDoubleElements(array)) return prefix + "_DOUBLE_ELEMENTS";6  if (%HasObjectElements(array)) return prefix + "_ELEMENTS";7  return "OTHER_ELEMENTS";8}9 10function report(name, array) {11  console.log(name + ": " + label(array));12}13 14console.log("Node " + process.version);15console.log("V8 " + process.versions.v8.split(".").slice(0, 2).join("."));16const values = [1, 2, 3];17report("packed smi", values);18values.push(4.5);19report("after double", values);20values.push("x");21report("after string", values);22values.pop();23values.pop();24report("after popping back", values);25const holey = new Array(3);26report("new Array", holey);27holey[0] = 1;28holey[1] = 2;29holey[2] = 3;30report("filled holey", holey);31const short = [1, 2, 3];32short[10] = 1;33report("write index 10", short);34const minusZero = [1, 2, 3];35minusZero.push(-0);36report("minus zero", minusZero);37const notANumber = [1, 2, 3];38notANumber.push(NaN);39report("NaN", notANumber);40const infinity = [1, 2, 3];41infinity.push(Infinity);42report("Infinity", infinity);43const sparse = [];44sparse[1e6] = 1;45report("sparse", sparse);

1console.log("Node " + process.version);2console.log("V8 " + process.versions.v8.split(".").slice(0, 2).join("."));3console.log("pointer compression", process.config.variables.v8_enable_pointer_compression);4console.log("2**31 - 1", %IsSmi(2 ** 31 - 1));5console.log("2**31", %IsSmi(2 ** 31));

Elements-kind transitions only widen

V8's common lattice moves from specific to general: packed Smi, packed double, packed generic, and the matching holey variants. The important rule is one-way movement. Once an array widens, V8 normally does not scan it later to prove it can narrow again.

1const fares = [1, 2, 3];Run2fares.push(4.5);3fares.push("₹");4fares.pop();5fares.pop();6console.log(fares.join(","));7console.log(fares.length);

Line 2 widens the array from packed Smi to packed double. Line 3 widens it again to packed generic elements. Lines 4 and 5 remove the values, so JavaScript prints 1,2,3 and length 3, but the V8-native test proves the internal kind stays generic.

1const arr = [1, 2, 3];2%DebugPrint(arr);

1const model = createElementsKindModel();2model.push(1);       // PACKED_SMI_ELEMENTS3model.push(2.5);     // PACKED_DOUBLE_ELEMENTS4model.push("₹");     // PACKED_ELEMENTS5model.writePastEnd(); // HOLEY_ELEMENTS6model.push(-0);      // still HOLEY_ELEMENTS

The playground is honest about its limits: it predicts V8's lattice for the shown sequence; it does not inspect the browser running this page. The test compares the same sequences with Node's real V8 natives.

Dictionary elements and sparse arrays

A sparse array has many missing indexes compared with its length. V8 can keep a moderately holey array in a fast holey backing store, but a very sparse array is better represented as a dictionary: a table of present indexes and values.

1const sparse = [];2sparse[1_000_000] = "Jaipur";3 4console.log(sparse.length);5console.log(0 in sparse);6console.log(1_000_000 in sparse);

If those numeric IDs are really sparse identifiers rather than positions in a list, a Map or plain object often communicates the data model better than an array with a million-length gap.

Backing-store growth

The array length is JavaScript-visible. The backing-store capacity is how much room the engine has allocated behind the scenes. Engines usually grow capacity by more than one slot so repeated push calls do not allocate every time.

1const orders = [];Run2orders.push(1);3for (let ticket = 2; ticket <= 18; ticket += 1) {4  orders.push(ticket);5}6orders.push(19);7console.log(orders.length);

1function newElementsCapacity(requestedCapacity) {2  return requestedCapacity + (requestedCapacity >> 1) + 16;3}4 5console.log(newElementsCapacity(1));6console.log(newElementsCapacity(18));7console.log(newElementsCapacity(44));

V8's source helper JSObject::NewElementsCapacity is documented as “old capacity plus 50% plus 16.” For the push path shown here, the capacity requested at the crossing is the new required length. That is why the first push asks for 1 and gets 17, while the 18th value asks for 18 and gets 43.

Array-likes are not arrays

An array-like object has numeric keys and a length, but it is not an actual array. The classic examples are arguments, older DOM collections, and objects you build yourself. Array methods can often be borrowed, but the optimized array path is not the same as a real array.

1function logArguments() {2  console.log(Array.isArray(arguments));3  console.log(arguments.length);4}5 6logArguments("Asha", "Ravi");7 8const list = { 0: "Asha", 1: "Ravi", length: 2 };9Array.prototype.forEach.call(list, (name, index) => {10  console.log(index + ":" + name);11});12console.log(Array.from(list).join("|"));

Use the knowledge safely

Elements kinds explain surprising profiles; they should not make normal code strange. Start with readable arrays. Measure the actual user-visible path. If a profile points at hot array work, then test a concrete hypothesis: avoid holes, avoid mixed value families in that hot array, or convert array-likes before repeated built-in calls.

1const readings = [];2for (const value of [18, 19, 20]) {3  if (Number.isFinite(value) && !Object.is(value, -0)) {4    readings.push(value);5  }6}7 8console.log(readings.join(","));

• Prefer array literals or repeated push over new Array(n) followed by filling when you care about packed storage.
• Normalize or reject -0, NaN, and Infinity only when the data model truly wants finite integers.
• Use Map or objects for sparse identifiers instead of pretending they are positions in a list.
• Use typed arrays for large numeric buffers when fixed element types are part of the problem.
• Measure before and after; exact V8 thresholds can change.

Common misconceptions

• “A hole is just `undefined`.” No. A hole is a missing property; 0 in array can be false.
• “Popping the weird value makes the array fast again.” The visible values change, but V8's elements kind does not usually narrow.
• “Every sparse array is dictionary immediately.” V8 has heuristics; the lesson proves a very sparse 1e6 write, not every gap.
• “Elements kinds are JavaScript types.” They are V8 implementation details. Other engines use their own strategies and names.
• “Engine internals beat clarity.” Clear code plus measurement beats cargo-cult rewrites.

Practice exercises

const fares = [1, 2, 3];
fares.push(4.5);
fares.push("₹");
fares.pop();
fares.pop();
console.log(fares.join(","));
console.log(fares.length);

const seats = new Array(3);
console.log(0 in seats);
seats[0] = "Asha";
console.log(seats[0]);

const list = { 0: "Asha", 1: "Ravi", length: 2 };
console.log(Array.from(list).join("|"));

const names = Array.from(list);
console.log(names.join("|"));

const items = [10, 20, 30];
let total = 0;
for (let i = 0; i <= items.length; i += 1) {
  total += items[i] ?? 0;
}
console.log(total);

for (let i = 0; i < items.length; i += 1) {
  total += items[i];
}

Check your understanding

Key takeaways

• V8 stores numeric indexes as elements, separate from named properties and hidden classes.
• Packed arrays have every index present; holey arrays have missing indexes and need extra checks.
• Smi arrays widen to double arrays, then generic arrays; transitions normally do not narrow again.
• Very sparse arrays can use dictionary elements, and array-like objects are not the same as real arrays.
• Backing stores grow with spare capacity; exact numbers are V8 details, so measure before optimizing.

In one line: dense, consistent arrays are the easy fast path; holes, mixed values, and sparse indexes ask the engine to do more work.

Next, Functions & closures inside the engine looks at function objects, shared function info, and the context objects closures retain.