TypeScript Sorting Arrays

Sorting means putting the elements of a collection in a certain order.

Some types have a natural order. Numbers are ordered by value: 1 comes before 2. Strings are ordered alphabetically: "four" comes before "one". For everything else, or when you want a different order, you give a custom order: a compare function that looks at two elements and says which one comes first.

Arrays have one sorting method, sort(), and two things about it are easy to miss:

• sort() changes the array in place and returns that same array, so the original order is gone. To keep it, sort a copy: [...words].sort().
• With no compare function, sort() compares the string form of the values. That is fine for words, but [10, 9, 2] comes out as [ 10, 2, 9 ], because the text "10" comes before "2". For numbers, always pass a compare function.

A compare function gets two elements, a and b, and returns a number: negative when a comes first, positive when b comes first, and 0 when they are equal. a - b does that for numbers and a.localeCompare(b) does it for strings.

sort() is stable: elements that the compare function calls equal keep their original order.

Newer versions of Node.js also have toSorted() and toReversed(), which return a new array and leave the original alone. The examples below copy the array by hand with [...words], which works everywhere.

The examples below use the words one, two, three, four.

Natural order is the order a type has on its own: numbers by value, strings letter by letter.

[...words].sort() gives a new array in alphabetical order. For descending order there is no separate method: sort first, then turn the array around with reverse(). For numbers, the compare function (a, b) => b - a does it in one step.

Your own object types have no natural order. You give them one by writing a compare function that returns a negative number, zero or a positive number, the same rule as any other compare function. You can then pass it to sort() or use it directly to compare two values.

[...words].sort() sorts a copy, so words itself is printed unchanged afterwards. The last two lines show why numbers need a compare function: without one, [10, 9, 2] becomes [ 10, 2, 9 ]; with (a, b) => a - b it becomes [ 2, 9, 10 ].

The copy is sorted, then reverse() flips it, so the words go from "two" down to "four". The numbers show the shorter way for values you can subtract: (a, b) => b - a sorts [10, 9, 2] straight into [ 10, 9, 2 ].

Version has a major and a minor number. compareVersion() compares major first; only when that result is 0 does minor decide, because || takes the first result that is not 0. Checking compareVersion(...) > 0 answers "is the first version greater?".

A custom order is any order you describe with a compare function.

sort() takes that function as its only argument. Because sort() is stable, elements the function calls equal stay in their original order, which is what you want when sorting words by length.

A common wish is to sort by one property of each element. There is no special method for that: write a compare function that compares that property, with - for numbers or localeCompare() for strings.

For descending order, swap a and b in the comparison.

To sort by one thing and then by another, join two comparisons with ||. It takes the first result that is not 0, so when the first comparison calls the elements equal, the second one breaks the tie.

The compare function returns a.length - b.length. A negative result means a is shorter and comes first, so the words end up from shortest to longest: [ 'c', 'bb', 'aaa' ].

The words are compared with a.length - b.length. "one" and "two" are both 3 letters long; because sort() is stable, "one" stays before "two".

a[a.length - 1] is the last letter of a word. The letters of b and a are compared in swapped order, so the word with the largest last letter comes first: "four" (r), then "two" (o), then the two words ending in "e" in their original order.

|| compares the lengths first. When two words are equally long, it falls back to localeCompare(), which orders them alphabetically. The result is printed with join(' '), on one line: a b c aa bb aaa ccc.

Sometimes you only want to know whether an array is already sorted, without sorting it.

There is no built-in check, but every() writes one in a single line: every element must come after the element before it. The small isSorted() helper below takes a compare function, so the same helper can check ascending order, descending order, or the order of one property. For descending order you pass a compare function with a and b swapped.

isSorted() confirms that 1, 2, 3, 4 are ascending. The same helper with (a, b) => b - a confirms that 4, 3, 2, 1 are descending. The element at index 0 is always accepted, because it has no element before it.

The users are Alice (24), Bob (31) and Charlie (29). The compare function looks only at age. Bob is older than Charlie, so the array is not sorted by age and the answer is false.

Reversing puts the last element first and the first element last.

reverse() reverses an array in place, just like sort() does. To get a reversed copy instead, reverse a copy: [...words].reverse(). The original keeps its order.

The copy is reversed and printed, then the original is printed to show it is unchanged.

Shuffling puts the elements in a random order.

There is no shuffle method. The usual way is a small loop that walks the array from the last position down and swaps each element with an element at an earlier position. The loop changes the array it is given, so shuffle a copy when you still need the original.

Math.random() would give a different order on every run. This example therefore seeds its own generator: two lines of arithmetic that turn a seed into a stream of numbers from 0 up to 1. The same seed always gives the same order, which is useful for tests and for examples like this one.

A generator with seed 9 shuffles a copy of the words and prints [ 'two', 'four', 'three', 'one' ]. Running the program again prints the same order, because the generator starts from the same seed.