This code defines a function `advancedOrder` that sorts a list...

September 4, 2025 at 03:23 AM

function advancedOrder(unorderedDataList) {
    unorderedDataList.sort(function(a, b) {
        //Make sure this sort is case insensitive
        var aDescription = a.short_description.toLowerCase();
        var bDescription = b.short_description.toLowerCase();

        // Regex to extract numeric prefixes (matching for "digit-digit")
        var aMatch = aDescription.match(/^(\d+)-(\d+)(.*)$/);
        var bMatch = bDescription.match(/^(\d+)-(\d+)(.*)$/);

        // If both have numeric prefixes
        if (aMatch && bMatch) {
            var aNumber = parseInt(aMatch[2], 10); // Extract numeric part for a
            var bNumber = parseInt(bMatch[2], 10); // Extract numeric part for b
            // If the numbers don't match, we compare then and sort numerically since we are comparing the number after the hyphen
            if (aNumber !== bNumber) {
                return aNumber - bNumber;
            }

            // If numeric parts are equal (potential duplication edge case), compare the text parts and sort as usual
            var aText = aMatch[2] ? aMatch[2].trim() : "";
            var bText = bMatch[2] ? bMatch[2].trim() : "";
            return aText.localeCompare(bText);
        }

        // If one has a numeric prefix and the other does not, the article with a number comes first
        if (aMatch && !bMatch) return -1;
        if (!aMatch && bMatch) return 1;

        // If neither has a numeric prefix, sort alphabetically
        return aDescription.localeCompare(bDescription);
    });

    return unorderedDataList; // Return the sorted list
}

This code defines a function advancedOrder that sorts a list of objects (unorderedDataList) based on the short_description property of each object. It considers both alphabetical order and specific numeric prefixes in the short_description. Here's what the code does in detail:

Case Insensitivity: Converts the short_description to lowercase before processing, ensuring the sorting is case-insensitive.
Regex Matching for Numeric Prefixes: Uses a regular expression ^(\d+)-(\d+)(.*)$ to identify and extract numeric prefixes formatted as digit1-digit2. This regex breaks the description into:
- The first group (\d+): The numeric part before the hyphen.
- The second group (\d+): The numeric part after the hyphen.
- The rest .*: The remaining part of the string.
Sorting Logic:
- If both short_description values have numeric prefixes:
  - Compare the second numeric part (the number that comes after the hyphen).
  - If these numbers differ, sort based on their numeric values (ascending order).
  - If these numbers are equal, compare the remaining text after the numeric prefix (alphabetical comparison).
- If only one of the descriptions has a numeric prefix, the one with the numeric prefix is prioritized and placed earlier in the sorted list.
- If neither description has a numeric prefix, the descriptions are sorted alphabetically.
Final Result: After processing according to these rules, the sorted list (unorderedDataList) is returned.

Example

let unorderedDataList = [
    { short_description: "10-2 Apples" },
    { short_description: "5-1 Oranges" },
    { short_description: "10-1 Bananas" },
    { short_description: "Apple Pie" }
];

let sortedList = advancedOrder(unorderedDataList);
console.log(sortedList);

Result of Sorting:

"5-1 Oranges" (sorted by numeric prefix 1 after '5-').
"10-1 Bananas" (sorted by numeric prefix after '10-').
"10-2 Apples" (next numeric prefix after '10-').
"Apple Pie" (no numeric prefix, sorted alphabetically at the end).

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr