Sorting Arrays
The .sort()
method sorts the elements of an array in place and returns the sorted array. By default, the sort method converts elements to strings and sorts them in lexicographical order.
Let me write some examples that will reinforce this concept in my brain.
Here, I take the following example with strings as elements:
How about numbers as elements? Letâ€™s look at the following example:
This is because, as mentioned in the first paragraph above, the .sort()
method converts elements to strings and sorts them in lexicographical order. This means that numbers, too, get converted to strings. In that sense, the sorting makes sense. But we donâ€™t want that, do we?
So how do we fix this?
To sort numbers or other types more effectively, we need to provide a comparator function.
Comparator Function?
Keeping it relevant to the topic here, the comparator function takes two arguments, typically referred to as a and b. This function should return:
 A negative number if a should come before b.
 A positive number if a should come after b.
 Zero if a and b are considered equal.
Iâ€™ll take the same example as above for this and apply the comparator function.
That was the ascending order. But what is happening? Two things:
Comparison Logic
 If a > b, the comparator function returns 1, indicating that a should come after b.
 If a < b, the comparator function returns 1, indicating that a should come before b.
 If a and b are equal, the comparator function returns 0, indicating no change in order.
But why does the positive return value swap a and b?
 The sort method uses the return value of the comparator function to determine the relative order of a and b.
 When the function returns a positive value (1), it indicates that a is greater than b, so a should come after b in the sorted order.
 When the function returns a negative value (1), it indicates that a is less than b, so a should come before b in the sorted order.
 Returning 0 means their order doesnâ€™t need to change because they are considered equal in the sort order.
Note that the original movements
array has been changed here. The .sort
method can change an array from its original state.
Another important note here is that it doesnâ€™t really matter whether itâ€™s 1 or a different positive number, as long as it's more than 0, it will always work.
Same is true for 1. As long as it's a negative number, it will always work.
Then, letâ€™s use this logic to simplify our comparison logic.
So, whatâ€™s going on in here? How I understand it is that the sort order here for any 2 consecutive elements in the array is (a, b) (and not the default lexicographical order since the order here is explicitly stated). If a  b
is positive, it means a is bigger than b. This causes .sort
to switch the positions of a and b.
In a broad overview, the result of
a  b
provides the necessary comparison:
 If
a > b
, thena  b
is positive, so a should come after b. If
a < b
, thena  b
is negative, so a should come before b. If
a === b
, thena  b
is 0, indicating they are equal in the sort order.
Visualizing the Sorting Process

First Pass: Compare 200 and 450
 200  450 = 250 (200 stays before 450)

Next Pass: Compare 200 and 400
 200  (400) = 600 (200 moves after 400)

Next Pass: Compare 400 and 450

400  450 = 850 (400 stays before 450)

Continue: The process continues for all elements in a similar manner until the entire array is sorted.
Conversely, we can do a denominatororder sorting with the same logic:
Caveat
If there is a mixed array, sort method is not advised.
This sorting in computer programming is called the comparisonbased sorting.