Why does [10, 9, 1].sort() return [1, 10, 9] in JavaScript, and how do you sort an array of numbers correctly?

## The behaviour `Array.prototype.sort()` is one of the few built-ins whose default behaviour surprises almost everyone the first time: ```js console.log([10, 9, 1].sort()); // [1, 10, 9] console.log([80, 9, 700].sort()); // [700, 80, 9] ``` This is not a bug and not an engine quirk — it is exactly what the specification requires. ## Why: ToString then code-unit comparison `sort` takes an optional comparator. When you call it with no argument (the comparator is `undefined`), the abstract sorting operation converts each element to a string with the `ToString` operation and compares those two strings, not the original values. String comparison in JavaScript is not alphabetical or linguistic — it walks the two strings and compares UTF-16 code units at the first position where they differ. For `10` and `9`, the strings are `"10"` and `"9"`. Position 0 already decides it: `'1'` is code unit 0x31 and `'9'` is 0x39, so `"10"` is "less than" `"9"`. Length never enters into it. That is why `700` beats `80` beats `9` in the second example. The default exists so that `sort()` has a defined result for arrays of mixed types without you telling it anything. It is a lowest-common-denominator rule, not a guess at your intent. ## The fix: a comparator A comparator is a two-argument function whose sign tells `sort` the order: negative means "`a` before `b`", zero means "treat as equivalent", positive means "`b` before `a`". ```js const nums = [10, 9, 1]; nums.sort((a, b) => a - b); // [1, 9, 10] ascending nums.sort((a, b) => b - a); // [10, 9, 1] descending ``` Subtraction is the idiomatic numeric comparator because it produces the right sign for free. It is safe for ordinary finite numbers. Two cases where subtraction is the wrong tool: values that are not numbers (a missing field makes `a - b` evaluate to `NaN`), and values where you want an explicit three-way comparison. For those, write the comparison out: ```js const byValue = (a, b) => (a < b ? -1 : a > b ? 1 : 0); ``` That form works for anything the relational operators order sensibly and never produces `NaN`. ## sort mutates in place `sort` reorders the receiver and returns *that same array*, not a copy: ```js const original = [3, 1, 2]; const result = original.sort((a, b) => a - b); console.log(result === original); // true console.log(original); // [1, 2, 3] — the original changed ``` This is a routine source of bugs when the array is shared: a cached list, an object property, or a value another part of the program still holds a reference to. If callers must not see the reordering, sort a copy — `[...arr].sort(cmp)` or `arr.slice().sort(cmp)`. ## undefined values and holes `sort` treats `undefined` specially. All `undefined` elements are moved to the end of the array and your comparator is **never called** with them, so you cannot make them sort first by writing clever comparator logic. In a sparse array, the empty slots end up after the `undefined` values. If you need a different policy for missing data, filter or normalise before sorting: ```js [3, undefined, 1].sort((a, b) => a - b); // [1, 3, undefined] ``` ## Things that look like fixes but are not - `arr.sort(Number)` — `sort` will call `Number` with two arguments and use the result of `Number(a)` as the comparison value, which is nonsense; the ordering it produces is not a numeric sort. - `arr.sort((a, b) => a > b)` — returns a boolean, which coerces to `1` or `0` and never to a negative number, so the comparator can never say "`a` first" and the result is unreliable. - Relying on the array "looking sorted" for small inputs — engines may take different code paths for short arrays, so a broken comparator can pass a three-element test and fail on a hundred. ## What to say in an interview Name the mechanism (`ToString` plus UTF-16 code-unit comparison), give the fix (`(a, b) => a - b`), and volunteer the two side facts that separate a memoriser from someone who has used it: in-place mutation of the receiver, and `undefined` sorting to the end.