Why does this code works?
<!DOCTYPE html>
<html>
<body>
<p id="demo">Click the button to sort the array.</p>
<button onclick="myFunction()">Try it</button>
<script>
function myFunction()
{
var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});
var x = document.getElementById("demo");
x.innerHTML=points;
}
</script>
</body>
</html>
It is taken from W3Schools
I am not understanding the points.sort(function(a,b){return a-b}); part.
What you have is the comparefunction argument syntax of Array.prototype.sort that you can use for customsorting. It performs the sorting based on the value you return from this function and the rules are as follows:
So you are just returning the difference between 2 numbers a & b which will return exactly what is needed by the sort compareFunction, (i.e -ve --> if a < b, +ve --> if a > b or 0 --> if a == b).
When you use a callback function with the sort method, it determines how to compare two items in the array.
If the values are equal, the callback function should return 0. If the first parameter should end up before the second, the callback should return a negative value, otherwise a positive value.
Here is a more descriptive implementation with the same result:
points.sort(function(a,b){
if (a == b) {
return 0;
} else if (a < b) {
return -1;
} else {
return 1;
}
});
The sort function takes a comparator function as its argument. The comparator function works liek this:
a-b fulfills this contract.
For example: if a = 40 and b = 100, then a-b = -60. So a < b.
.sort() allows you to pass a function to define how the array is sorted. The goal is to return a positive (>=0) or negative number (<0) in relation to the two currently compared items. The idea is if you take a and subtract from b, if a is greater than b then a positive is returned and therefore a will be ranked higher than b. If a is less than b a negative is returned and b is ranked higher than a.
The sort function works by looking at whether the value returned by the comparator function is negative or positive. Basically, if it's positive, it swaps the numbers. If it's negative or zero, it leaves them in that order. It keeps traversing the array until all pairs return a non-positive value.
In this case:
and so on... This is fairly inefficient, so it's likely that under the hood, something more efficient is going on, but for the purposes of predicting your output, this is sufficient.
You could write your sort function like this and get the same result:
function(a, b) {
if (a > b) return 1;
else if (a < b) return -1;
else return 0;
}
points.sort(function(a,b){return a-b});part.function(a,b){return a-b}.