JavaScript sort Boolean Comparator: Test and Fix Wrong Order

Check both directions of the comparison#

The ECMAScript comparison algorithm converts a callback’s result to a number. Thus false becomes 0 and true becomes 1; neither result is negative.

For ascending order, a negative result places a before b, zero treats them as equivalent for sorting, and a positive result places a after b. The magnitude need not be exactly one.

Compare the same pair in both directions:

MDN’s comparator rules require these signs to oppose each other, or both to be zero. Comparisons also need consistent results, reflexivity, and transitivity. A callback should not change the compared values or external state.

Wrapping a > b in Number(...) does not fix it: the result still has only zero and positive values. Sorting stability does not fix it either. The specification leaves the order implementation-defined when the comparator is inconsistent. Do not depend on one browser’s apparent success.

Reproduce the defect across input orders#

Save this as sort-contract.mjs and run node sort-contract.mjs. The exact fixture was executed during article preparation on macOS with Node.js 24.13.0 on October 10, 2026. It requires no packages.

The fixture checks comparison signs and transitivity on a small sample, tries all six permutations of three distinct numbers, and verifies the source-array behavior. This is a regression check for these inputs, not a proof for every possible value or custom comparator.

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

3
const bad = (a, b) => a > b;
4
const ascending = (a, b) => a - b;
5
const sign = (compare, a, b) => Math.sign(Number(compare(a, b)));
6

7
function checkSample(compare, values) {
8
  for (const a of values) {
9
    assert.equal(sign(compare, a, a), 0, 'reflexivity');
10
    for (const b of values) {
11
      const ab = sign(compare, a, b);
12
      const ba = sign(compare, b, a);
13
      assert.ok(Number.isFinite(ab) && Number.isFinite(ba), 'numeric result');
14
      assert.ok(ab === -ba, 'opposite signs or both zero');
15
      for (const c of values) {
16
        if (ab <= 0 && sign(compare, b, c) <= 0) {
17
          assert.ok(sign(compare, a, c) <= 0, 'transitivity');
18
        }
19
      }
20
    }
21
  }
22
}
23

24
assert.equal(Number(bad(1, 2)), 0);
25
assert.equal(Number(bad(2, 1)), 1);
26
assert.throws(() => checkSample(bad, [1, 2, 3]), /opposite signs/);
27
checkSample(ascending, [-2, 0, 1, 2, 3]);
28
console.log('boolean comparator rejected; numeric comparator passed sample');
29

30
const inputs = [
31
  [1, 2, 3], [1, 3, 2], [2, 1, 3],
32
  [2, 3, 1], [3, 1, 2], [3, 2, 1],
33
];
34
let failures = 0;
35
for (const input of inputs) {
36
  const broken = input.toSorted(bad);
37
  const fixed = input.toSorted(ascending);
38
  if (JSON.stringify(broken) !== '[1,2,3]') failures++;
39
  assert.deepEqual(fixed, [1, 2, 3]);
40
  console.log(`${JSON.stringify(input)} => boolean ${JSON.stringify(broken)}; numeric ${JSON.stringify(fixed)}`);
41
}
42
assert.ok(failures > 0);
43
console.log(`boolean failures: ${failures}/${inputs.length}`);
44
assert.deepEqual([10, 2, 1].toSorted(), [1, 10, 2]);
45
assert.deepEqual([10, 2, 1].toSorted(ascending), [1, 2, 10]);
46
assert.deepEqual([2, 0, -2, 2].toSorted(ascending), [-2, 0, 2, 2]);
47

48
const source = [3, 1, 2];
49
const copied = source.toSorted(ascending);
50
assert.deepEqual(source, [3, 1, 2]);
51
assert.notEqual(copied, source);
52
const returned = source.sort(ascending);
53
assert.equal(returned, source);
54
assert.deepEqual(source, [1, 2, 3]);
55
console.log('toSorted preserves source; sort returns and mutates source');
56
console.log('all assertions passed');

Output in the checked environment:

1
boolean comparator rejected; numeric comparator passed sample
2
[1,2,3] => boolean [1,2,3]; numeric [1,2,3]
3
[1,3,2] => boolean [1,3,2]; numeric [1,2,3]
4
[2,1,3] => boolean [2,1,3]; numeric [1,2,3]
5
[2,3,1] => boolean [2,3,1]; numeric [1,2,3]
6
[3,1,2] => boolean [3,1,2]; numeric [1,2,3]
7
[3,2,1] => boolean [3,2,1]; numeric [1,2,3]
8
boolean failures: 5/6
9
toSorted preserves source; sort returns and mutates source
10
all assertions passed

The boolean callback passes the already sorted case and fails the other five here. That failure count is an observed Node result, not a cross-engine guarantee. The pairwise contract check identifies the defect without relying on the sorting algorithm’s call order.

Choose the result’s ownership separately#

sort() reorders the original array and returns that same array. Assigning its return value to another variable does not make a copy. toSorted() returns a new array.

For the dense numeric arrays used here:

A copied array does not deep-clone objects stored inside it. If you adapt this to records, sorting the copy and editing a record are separate operations.

Keep the numeric boundary explicit#

Omitting the comparator is a different error: ordinary arrays use string comparison by default, so the fixture verifies [10, 2, 1] becoming [1, 10, 2]. It also checks negative values, zero, and duplicate numbers with the numeric callback.

This fix assumes finite numbers, not numeric strings, NaN, undefined, sparse arrays, or mixed data. The sample checker does not validate your application’s input schema. Check or normalize incoming values before sorting, with an explicit policy for missing and invalid fields. A callback result of NaN is treated as zero by the specification, so subtracting an invalid value can silently turn a comparison into equivalence.

If the numbers come from repeated URL query fields, preserve those fields before converting the query to an object, then parse and validate their values. Sorting cannot recover values discarded earlier.

The published fixture was not run in browsers, a framework component, or older Node versions. In your target runtime, check toSorted availability and run the regression fixture. Keep the comparator’s sign contract and the source-array ownership requirement as separate checks.

References:

• ECMAScript: CompareArrayElements
• ECMAScript: SortIndexedProperties
• MDN: Array.prototype.sort()
• MDN: Array.prototype.toSorted()