Comprehensive Analysis of JavaScript Array Sorting: From String Comparison to Numerical Sorting

Fundamental Principles of JavaScript Array Sorting

In JavaScript programming, array sorting represents a fundamental and crucial operation. The sort() method of array objects provides built-in sorting functionality, but its default behavior often confuses beginners. Understanding how the sort() method works is key to mastering proper sorting techniques.

Limitations of Default Sorting Behavior

JavaScript's sort() method defaults to converting array elements to strings and then sorting them according to Unicode code point order. This design produces unexpected results when dealing with pure numeric arrays. Consider the following example:

var numArray = [140000, 104, 99];
numArray.sort();
console.log(numArray); // Output: [104, 140000, 99]

This result differs completely from the intuitive numerical expectation of [99, 104, 140000]. The reason lies in string comparison: during Unicode comparison, the first character "1" of "104" has a lower value than the first character "1" of "140000" but higher than the first character "9" of "99", thus producing seemingly incorrect sorting order.

Implementing Numerical Sorting with Custom Comparison Functions

To resolve the default sorting issue, you need to pass a comparison function to the sort() method. This function receives two parameters, a and b, and determines their relative order based on the return value:

var numArray = [140000, 104, 99];
numArray.sort(function(a, b) {
  return a - b;
});
console.log(numArray); // Output: [99, 104, 140000]

The comparison function operates based on subtraction results: when a - b returns a negative value, a comes before b; when positive, a comes after b; when zero, their relative positions remain unchanged. This mechanism ensures numbers are correctly ordered from smallest to largest.

Implementing Ascending and Descending Order

By adjusting the logic of the comparison function, you can easily implement different sorting orders. For ascending order, use a - b; for descending order, use b - a:

// Ascending order
var ascendingArray = [10, 5, 80, 2];
ascendingArray.sort((a, b) => a - b);
console.log(ascendingArray); // Output: [2, 5, 10, 80]

// Descending order  
var descendingArray = [10, 5, 80, 2];
descendingArray.sort((a, b) => b - a);
console.log(descendingArray); // Output: [80, 10, 5, 2]

Handling Special Numerical Cases

When using comparison functions, special attention must be paid to handling unique numerical values. When arrays contain Infinity or NaN, simple subtraction comparisons may produce unexpected results:

var specialArray = [5, Infinity, 3, -Infinity, NaN];
specialArray.sort((a, b) => a - b);
console.log(specialArray); // May produce unexpected results

For arrays containing special values, more robust comparison logic is needed to handle edge cases properly.

Techniques for Avoiding Original Array Modification

The sort() method directly modifies the original array, which may not be desirable in certain scenarios. To preserve the original array unchanged, create a copy before sorting:

var originalArray = [3, 1, 4, 2];
var sortedArray = originalArray.slice().sort((a, b) => a - b);
console.log(originalArray); // Output: [3, 1, 4, 2]
console.log(sortedArray);   // Output: [1, 2, 3, 4]

Optimizing String Array Sorting

While this article primarily focuses on numerical sorting, comparison functions are equally applicable to custom sorting of string arrays. For example, implementing case-insensitive alphabetical sorting:

var stringArray = ["Apple", "banana", "Cherry", "date"];
stringArray.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
console.log(stringArray); // Output: ["Apple", "banana", "Cherry", "date"]

Analysis of Practical Application Scenarios

In practical development, numerical sorting requirements are extremely common. From simple number lists to complex data structures, correct sorting algorithms significantly enhance program reliability and user experience. Mastering the use of comparison functions helps developers avoid common sorting pitfalls and write more robust JavaScript code.