Logic behind reverse compare function in the array.sort() method

From the Mozilla documentation:

If compareFunction is supplied, the array elements are sorted according to the return value of the compare function. If a and b are two elements being compared, then:

If compareFunction(a, b) is less than 0, sort a to a lower index than b, i.e. a comes first. If compareFunction(a, b) returns 0, leave a and b unchanged with respect to each other, but sorted with respect to all different elements. Note: the ECMAscript standard does not guarantee this behaviour, and thus not all browsers (e.g. Mozilla versions dating back to at least 2003) respect this.

If compareFunction(a, b) is greater than 0, sort b to a lower index than a.

compareFunction(a, b) must always return the same value when given a specific pair of elements a and b as its two arguments. If inconsistent results are returned then the sort order is undefined.

Imagine that your Array has only 2 items: 100 and 60. What happens is that when 100 is compared with 60 the function returns 40, which is a positive value. When 60 is compared with 100 the function returns -40 which is a negative value... That's how sort knows where to put each element.

Perhaps you are getting confused because you don't understand how sorting algorithms work internally, if that's the case have a look at these 2:

• Heapsort
• Mergesort

Be aware that your comparison function is not guaranteed to be called only once per entry of your array, and it is certainly not done in linear time (O(n)) but depending on the algorithm, it is at best O(n log n).

What I mean is that, 40 will not only be compared to 100, but also to 1 and 5 etc. so you (human) can't really predict at sight that 100 - 40 will sort it in the specific way you expect it to just after the comparison (several comparisons occur per value), because there are several steps that determine the final index of each value.

According to definition of sort() method is to sort the elements of an array in place and returns the array. The default sort is according to string Unicode code points.

Compare pudocode looks like:

function compare(a, b) {
  if (a is less than b by some ordering criterion) {
     return -1;
  }
  if (a is greater than b by the ordering criterion) {
    return 1;
  }
  // a must be equal to b
  return 0;
}

To compare number:

function compare(a, b) {
   return a - b;
}

Functionally, (ignoring the fact that integer overflow occurs for the maximum values), what happens for ascending order (a-b), is equivalent to the following.

var ascSort = function(a, b) {
    if (a > b) { 
        return 1;
    }  else if (a < b) {
        return -1;
    } else {
        return 0;
    }
}

And descending order, just negate the return values to flip the ordering

var descSort = function(a, b) {
    if (a > b) { 
        return -1;
    }  else if (a < b) {
        return 1;
    } else {
        return 0;
    }
}

And so you can now do

[40, 100, 1, 5, 25, 10].sort(ascSort); // [1, 5, 10, 25, 40, 100]
[40, 100, 1, 5, 25, 10].sort(descSort); // [100, 40, 25, 10, 1]