How to sort strings in JavaScript numerically

Another variant is to use an instance of Intl.Collator with the numeric option:

var array = ["a100", "a20", "a3", "a3b", "a3b100", "a3b20", "a3b3", "!!", "~~", "9", "10", "9.5"];
var collator = new Intl.Collator([], {numeric: true});
array.sort((a, b) => collator.compare(a, b));
console.log(array);

Assuming you want to just do a numeric sort by the digits in each array entry (ignoring the non-digits), you can use this:

function sortByDigits(array) {
    var re = /\D/g;
    
    array.sort(function(a, b) {
        return(parseInt(a.replace(re, ""), 10) - parseInt(b.replace(re, ""), 10));
    });
    return(array);
}

It uses a custom sort function that removes the digits and converts to a number each time it's asked to do a comparison. You can see it work here: http://jsfiddle.net/jfriend00/t87m2/.

Use this compare function for sorting...

function compareLists(a, b) {
    var alist = a.split(/(\d+)/), // Split text on change from anything
                                  // to digit and digit to anything
        blist = b.split(/(\d+)/); // Split text on change from anything
                                  // to digit and digit to anything

    alist.slice(-1) == '' ? alist.pop() : null; // Remove the last element if empty

    blist.slice(-1) == '' ? blist.pop() : null; // Remove the last element if empty

    for (var i = 0, len = alist.length; i < len; i++) {
        if (alist[i] != blist[i]){ // Find the first non-equal part
           if (alist[i].match(/\d/)) // If numeric
           {
              return +alist[i] - +blist[i]; // Compare as number
           } else {
              return alist[i].localeCompare(blist[i]); // Compare as string
           }
        }
    }

    return true;
}

Syntax

var data = ["a1b3", "a10b11", "b10b2", "a9b2", "a1b20", "a1c4"];
data.sort(compareLists);
alert(data);

There is a demo at http://jsfiddle.net/h9Rqr/7/.

Here's a more complete solution that sorts according to both letters and numbers in the strings

function sort(list) {
    var i, l, mi, ml, x;
    // copy the original array
    list = list.slice(0);

    // split the strings, converting numeric (integer) parts to integers
    // and leaving letters as strings
    for( i = 0, l = list.length; i < l; i++ ) {
        list[i] = list[i].match(/(\d+|[a-z]+)/g);
        for( mi = 0, ml = list[i].length; mi < ml ; mi++ ) {
            x = parseInt(list[i][mi], 10);
            list[i][mi] = !!x || x === 0 ? x : list[i][mi];
        }
    }

    // sort deeply, without comparing integers as strings
    list = list.sort(function(a, b) {
        var i = 0, l = a.length, res = 0;
        while( res === 0 && i < l) {
            if( a[i] !== b[i] ) {
                res = a[i] < b[i] ? -1 : 1;
                break;
            }

            // If you want to ignore the letters, and only sort by numbers
            // use this instead:
            // 
            // if( typeof a[i] === "number" && a[i] !== b[i] ) {
            //     res = a[i] < b[i] ? -1 : 1;
            //     break;
            // }

            i++;
        }
        return res;
    });

    // glue it together again
    for( i = 0, l = list.length; i < l; i++ ) {
        list[i] = list[i].join("");
    }
    return list;
}

I needed a way to take a mixed string and create a string that could be sorted elsewhere, so that numbers sorted numerically and letters alphabetically. Based on answers above I created the following, which pads out all numbers in a way I can understand, wherever they appear in the string.

function padAllNumbers(strIn) {
    // Used to create mixed strings that sort numerically as well as non-numerically
    var patternDigits = /(\d+)/g; // This recognises digit/non-digit boundaries
    var astrIn = strIn.split( patternDigits ); // we create an array of alternating digit/non-digit groups

    var result = "";

    for (var i=0;i<astrIn.length;  i++) {
        if (astrIn[i] != "") { // first and last elements can be "" and we don't want these padded out
            if (isNaN(astrIn[i])) {
                result += astrIn[i];
            } else {
                result += padOneNumberString("000000000",astrIn[i]);
            }
        }
    }
    return result;
}

function padOneNumberString(pad,strNum,left) {
    // Pad out a string at left (or right)
    if (typeof strNum === "undefined") return pad;
    if (typeof left === "undefined") left = true;
    var padLen =  pad.length - (""+ strNum).length;
    var padding = pad.substr(0,padLen);
    return left?  padding + strNum : strNum + padding;
}

Sorting occurs from left to right unless you create a custom algorithm. Letters or digits are compared digits first and then letters.

However, what you want to accomplish as per your own example (a1, a9, a10) won’t ever happen. That would require you knowing the data beforehand and splitting the string in every possible way before applying the sorting.

One final alternative would be:

a) break each and every string from left to right whenever there is a change from letter to digit and vice versa; & b) then start the sorting on those groups from right-to-left. That will be a very demanding algorithm. Can be done!

Finally, if you are the generator of the original "text", you should consider NORMALIZING the output where a1 a9 a10 could be outputted as a01 a09 a10. This way you could have full control of the final version of the algorithm.