Detailed explanation of how JavaScript uses the sort() method to sort multi-dimensional arrays and object arrays

The sort() method is used to sort the elements of an array. The syntax is as follows:

arrayObject.sort(sortby)

The return value is a reference to the array. Please note that the array is sorted on the original array, no copy is made.

If this method is called without parameters, the elements in the array will be sorted alphabetically, or more precisely, in character encoding order. To achieve this, the elements of the array should first be converted to strings (if necessary) for comparison.

If you want to sort by other criteria, you need to provide a comparison function, which compares two values ​​and returns a number that describes the relative order of the two values. The comparison function should have two parameters a and b, and its return value is as follows:

If a is less than b, a should appear before b in the sorted array, then a value less than 0 is returned. .
If a is equal to b, return 0.
If a is greater than b, return a value greater than 0.

function NumAscSort(a,b)
{
 return a - b;
}
function NumDescSort(a,b)
{
 return b - a;
}
var arr = new Array( 3600, 5010, 10100, 801); 
arr.sort(NumDescSort);
alert(arr);
arr.sort(NumAscSort);
alert(arr);

sort(fun) accepts a sorting rule function. This function will compare the size of two numbers. In fact, the principle of our object array sorting is the same.
If you do not compare the size of the numbers, you can do this:

var myarray=["Apple", "Banana", "Orange"]
myarray.sort()

After the array directly calls sort(), the array sorts the elements in the array in alphabetical order. To be more precise, it is sorted according to the order of character encoding.
For object array sorting, we first write a function that constructs a comparison function:

//by函数接受一个成员名字符串做为参数
//并返回一个可以用来对包含该成员的对象数组进行排序的比较函数
var by = function(name){
 return function(o, p){
   var a, b;
   if (typeof o === "object" && typeof p === "object" && o && p) {
     a = o[name];
     b = p[name];
     if (a === b) {
       return 0;
     }
     if (typeof a === typeof b) {
       return a < b ? -1 : 1;
     }
     return typeof a < typeof b ? -1 : 1;
   }
   else {
     throw ("error");
   }
 }
}

The array to be sorted:

var employees=[]
employees[0]={name:"George", age:32, retiredate:"March 12, 2014"}
employees[1]={name:"Edward", age:17, retiredate:"June 2, 2023"}
employees[2]={name:"Christine", age:58, retiredate:"December 20, 2036"}
employees[3]={name:"Sarah", age:62, retiredate:"April 30, 2020"}

Directly call the function:

employees.sort(by("age"));

At this point, the object array sorting is basically implemented. So how to implement multiple key value sorting? This means that the ages are sorted first, and if the ages are the same, the names are compared.
At this time, we can further modify the by function so that it can accept a second parameter. When the main key value generates a match, another compare method will be called to determine the winner.

//by函数接受一个成员名字符串和一个可选的次要比较函数做为参数
//并返回一个可以用来包含该成员的对象数组进行排序的比较函数
//当o[age] 和 p[age] 相等时，次要比较函数被用来决出高下
var by = function(name,minor){
 return function(o,p){
   var a,b;
   if(o && p && typeof o === 'object' && typeof p ==='object'){
     a = o[name];
     b = p[name];
     if(a === b){
       return typeof minor === 'function' ? minor(o,p):0;
     }
     if(typeof a === typeof b){
       return a < b ? -1:1;
     }
     return typeof a < typeof b ? -1 : 1;
   }else{
     thro("error");
   }
 }
}

employees.sort(by('age',by('name')));

Okay, now you can use it with confidence. If you don’t understand it, you can directly copy the by function into your application and call it directly.

The above is the detailed content of Detailed explanation of how JavaScript uses the sort() method to sort multi-dimensional arrays and object arrays. For more information, please follow other related articles on the PHP Chinese website!