How Does sort() Actually Sort?

Sort takes an optional comparison function. If you do not supply one, it compares the elements as strings, which is why sorting numbers without a comparator gives you an obviously wrong result.

The reason is that the default comparison converts both values to strings and compares them character by character. So ten comes before nine, because the string "10" sorts before "9" in character order.

When you do supply a comparator, the contract is simple. The comparator receives two elements and returns a negative number when the first should come before the second, zero when they are equivalent, and a positive number when the first should come after the second. You do not have to return minus one, zero and one; any negative and any positive value work, and returning the difference of the two values is the usual shortcut.

Two properties are worth knowing. Sort is stable in modern engines, meaning that elements the comparator treats as equal keep their original relative order. That matters when you sort by one field and then expect a secondary field to be preserved. And sort mutates the array it is called on, which is why the newer toSorted method is often the safer choice, since it returns a sorted copy instead.

Numbers need a comparator that subtracts, and objects need a comparator that compares the field you care about. Without a comparator, both go wrong in ways that are easy to miss.

const numbers = [10, 9, 100, 1];

console.log(numbers.slice().sort());                 // [1, 10, 100, 9] - string order
console.log(numbers.slice().sort((a, b) => a - b));  // [1, 9, 10, 100]

const people = [
  { name: "Cleo", age: 34 },
  { name: "Ada", age: 36 },
  { name: "Bob", age: 28 },
];

console.log(people.slice().sort((a, b) => a.age - b.age).map((p) => p.name));
// ["Bob", "Cleo", "Ada"]

console.log(people.slice().sort((a, b) => a.name.localeCompare(b.name)).map((p) => p.name));
// ["Ada", "Bob", "Cleo"]

// The newer method returns a new array instead of mutating.
console.log(numbers.toSorted((a, b) => a - b));   // [1, 9, 10, 100]
console.log(numbers);                              // [10, 9, 100, 1] - unchanged

Three practical points. The slice calls are there because sort changes the array in place, and copying first keeps the original available. The localeCompare method is the right way to sort strings, because it respects the rules of the user's language rather than comparing raw character codes, which puts all the uppercase letters before all the lowercase ones. And for descending order, you negate the comparator result rather than writing a separate function.

One more trap worth knowing. If you sort an array of objects by a field that might be missing on some of them, the comparator will try to subtract or compare a missing value and produce a result of not-a-number, and the resulting order becomes unpredictable. Guard for missing fields in the comparator, or sort by a computed key that always exists.