JavaScript toSorted Turns Array Holes into undefined: Keep Empty Slots

Check whether the index exists#

In [30, , undefined, 2], both index 1 and index 2 read as undefined. Only index 2 is an own property. Use Object.hasOwn() to distinguish an absent property from one holding undefined. Reading the value or checking the array length misses the difference.

The ECMAScript sorting algorithm lets sort() skip absent indexes and lets toSorted() read through them. On ordinary arrays without inherited numeric properties, slice() copies the present indexes and leaves the holes in place before sort() runs. Array spread reads the holes as undefined during the copy, so [...source].sort(compare) already has explicit entries by the time sorting begins. ECMAScript sorting algorithm

Verify which entries reach the next callback#

Save the fixture as sparse-sort.mjs and run node sparse-sort.mjs. It was executed during article preparation on November 7, 2026, with Node.js 24.13.0 on macOS. The input uses ordinary array slots, finite numbers, and one explicit undefined.

1
import assert from 'node:assert/strict';
2

3
const source = [30, , undefined, 2];
4
const ascending = (a, b) => a - b;
5
const cases = [
6
  ['toSorted', source.toSorted(ascending), [0, 1, 2, 3]],
7
  ['spread + sort', [...source].sort(ascending), [0, 1, 2, 3]],
8
  ['slice + sort', source.slice().sort(ascending), [0, 1, 2]],
9
];
10

11
for (const [label, result, expectedIndexes] of cases) {
12
  const visited = [];
13
  result.map((_, index) => visited.push(index));
14

15
  assert.notEqual(result, source);
16
  assert.equal(result.length, 4);
17
  assert.deepEqual(result.slice(0, 2), [2, 30]);
18
  assert.equal(result[2], undefined);
19
  assert.equal(result[3], undefined);
20
  assert.equal(Object.hasOwn(result, 3), expectedIndexes.includes(3));
21
  assert.deepEqual(visited, expectedIndexes);
22

23
  console.log(`${label}: map visits ${visited.join(', ')}`);
24
}
25

26
assert.deepEqual(source, [30, , undefined, 2]);
27
assert.equal(Object.hasOwn(source, 1), false);
28
assert.equal(Object.hasOwn(source, 2), true);

1
toSorted: map visits 0, 1, 2, 3
2
spread + sort: map visits 0, 1, 2, 3
3
slice + sort: map visits 0, 1, 2

All three results have the same length and start with [2, 30]. Only the slice().sort() result leaves index 3 empty. Index 2 still holds the original explicit undefined, so map() calls its callback there in all three cases.

Choose toSorted() when every output position should be present. Choose slice().sort(compare) when downstream code must distinguish empty slots from explicit values. The latter preserves the number of holes. If the original positions carry meaning, keep the source indexes with the entries before sorting.

References:

• ECMAScript Array.prototype.toSorted
• ECMAScript Array.prototype.slice
• MDN Array.prototype.sort on sparse arrays