JavaScript Array Sort() Method

Output:

[ 'ant', 'bee', 'Cat', 'dog', 'Elephant' ]

Sorting an Array of Strings with Non-ASCII Characters

With strings containing ASCII characters, the sort() method functions as intended. However, the sort() method will not function properly for strings that contain non-ASCII characters, such as é, è, etc. For instance:

let animaux = ['zèbre', 'abeille', 'écureuil', 'chat'];
animaux.sort();

console.log(animaux);

The écureuil string, as you can see, ought to come before the zèbre string.

To fix this, compare strings in a certain locale using the localeCompare() function of the String object, like in the following example:

animaux.sort(function (a, b) {
    return a.localeCompare(b);
});
console.log(animaux);

Output:

[ 'abeille', 'chat', 'écureuill', 'zèbree' ]

The elements of the animaux array now are in the correct order.

Sorting an Array of Numbers

Assume you have a collection of scores, like in the example below.

let scores = [
    9, 80, 10, 20, 5, 70
];

You must input a custom comparison function that compares two numbers into an array of numbers in order to numerically sort them.
The scores array is numerically sorted in ascending order in the example that follows.

let scores = [
    9, 80, 10, 20, 5, 70
];
// sort numbers in ascending order
scores.sort((a, b) => a - b);

console.log(scores);

Output:

[ 5, 9, 10, 20, 70, 80 ]

You just need to use the compare function’s logic in the other direction, as seen in the example below, to numerically arrange an array of integers in descending order:

let scores = [
    9, 80, 10, 20, 5, 70
];
// descending order
scores.sort((a, b) => b - a);
console.log(scores);

Output:

[80, 70, 20, 10, 9, 5]

Sorting an Array of Objects by a Specified Property

An array of employee objects is shown below. Each object has the three values name, salary, and hireDate.

let employees = [
    {name: 'John', salary: 90000, hireDate: "July 1, 2010"},
    {name: 'David', salary: 75000, hireDate: "August 15, 2009"},
    {name: 'Ana', salary: 80000, hireDate: "December 12, 2011"}
];

Sorting Objects by a Numeric Property

The method for sorting the employees’ salaries in ascending order is demonstrated in the example below.

// sort by salary
employees.sort(function (x, y) {
    return x.salary - y.salary;
});

console.table(employees);

This illustration is comparable to the illustration of sorting an array of integers upwards. The distinction is because it contrasts two items salaries as opposed to other properties.

Sorting Objects by a String Property

You supply the compare function, which compares two strings case-insensitively, the following information in order to case-insensitively arrange the workers array by name property:

employees.sort(function (x, y) {
    let a = x.name.toUpperCase(),
        b = y.name.toUpperCase();
    return a == b ? 0 : a > b ? 1 : -1;
});

console.table(employees);

Sorting Objects by the Date Property

Lets say you want to organise the workers by the date they were hired.

The hireDate property of the employee object contains the hiring date information. However, it isn’t the Date object; rather, it’s only a string that symbolises a legitimate date.

Therefore, in order to compare two dates, which is equivalent to comparing two integers, you must first generate a valid Date object from the date string.
The answer is as follows:

employees.sort(function (x, y) {
    let a = new Date(x.hireDate),
        b = new Date(y.hireDate);
    return a - b;
});

console.table(employees);

Optimising JavaScript Array sort() Method

In actuality, the comparison function is used many times by the sort() method for each entry in the array.
See the example below:

let rivers = ['Nile', 'Amazon', 'Congo', 'Mississippi', 'Rio-Grande'];

rivers.sort(function (a, b) {
    console.log(a, b);
    return a.length - b.length;
});

Output:

Amazon Nile
Congo Amazon
Congo Amazon
Congo Nile
Mississippi Congo
Mississippi Amazon
Rio-Grande Amazon
Rio-Grande Mississippi

How it works:

• Declare a list of rivers first, including just the well-known river names.
• Second, use the sort() function to order the river array according to the length of each entry. Every time the sort() method uses the comparison function, we report the contents of the rivers array to the browser console.
• Each element has been assessed more than once, as seen in the result above, for example, Amazon has been reviewed four times and Congo twice.
• Performance might be affected by an increase in the number of array elements.
• The number of times the comparison function is used cannot be decreased. You may, however, lessen the amount of effort the comparison needs to perform. This process is known as the Schwartzian Transform.

To implement this, you follow these steps:

1. Use the map() function to first extract the real values into a temporary array.
2. Next, order the temporary array by already-evaluated items (or transformed).
3. Third, navigate the informal array to obtain an array containing the proper ad hoc.

Here is the solution:

// temporary array holds objects with position
// and length of element
var lengths = rivers.map(function (e, i) {
    return {index: i, value: e.length };
});

// sorting the lengths array containing the lengths of
// river names
lengths.sort(function (a, b) {
    return +(a.value > b.value) || +(a.value === b.value) - 1;
});

// copy element back to the array
var sortedRivers = lengths.map(function (e) {
    return rivers[e.index];
});

console.log(sortedRivers);

Output:

[ 'Nile', 'Congo', 'Amazon', 'Rio-Grande', 'Mississippi' ]

Conclusion
The JavaScript Array..sort() method is a powerful tool for sorting the elements of an array. It provides flexibility and customization options for sorting arrays of different data types. The method sorts the elements in place and returns the sorted array. It uses a stable sorting algorithm, typically a variant of quicksort or mergesort, to efficiently sort the array.

Frequently Asked Questions (FAQs):

Q1: How does the sort() method work in JavaScript?
The sort() method in JavaScript converts the elements of the array into strings and then compares them based on their Unicode code points. By default, the elements are sorted in ascending order. The method modifies the original array and returns the sorted array.

Q2: Can I use the sort() method to sort arrays of different data types?
Yes, the sort() method can sort arrays containing elements of different data types. However, the sorting order may not always be intuitive. For example, if you have an array of numbers and strings, the numbers will be converted to strings and sorted based on their Unicode code points.

Q3: How can I customize the sorting order using the sort() method?
The sort() method accepts an optional compare function that can be used to define a custom sorting order. The compare function takes two parameters (a and b) representing two elements being compared. It should return a negative value if a should be placed before b, a positive value if a should be placed after b, and 0 if both elements are equal in terms of sorting.

Q4: Can the sort() method handle the sorting of complex objects?
Yes, the sort() method can sort arrays of complex objects. By providing a compare function that specifies the sorting criteria based on specific object properties, you can customize the sorting order for complex objects. For example, you can sort an array of objects based on their name or age properties.

Q5: What is the time complexity of the sort() method?
The time complexity of the sort() method depends on the sorting algorithm used by the JavaScript engine. In most modern engines, the average time complexity is O(n log n), where n is the number of elements in the array. However, it’s important to note that the worst-case time complexity can be O(n^2) for some sorting algorithms, depending on the data and the compare function used.

Q6: Does the sort() method modify the original array?
Yes, the sort() method modifies the original array in place. It rearranges the elements of the array according to the sorting order and returns the sorted array. If you want to preserve the original array, you should create a copy of it before applying the sort() method.