我想对字符串数组（在javascript中）进行排序，以便将字符串中的数字组作为整数而不是字符串进行比较。我并不担心签名或浮点数。
例如，结果应为["a1b3","a9b2","a10b2","a10b11"]而不是["a1b3","a10b11","a10b2","a9b2"]
最简单的方法似乎是在数字组周围的边界上拆分每个字符串。是否有一种模式可以传递给String.split以在字符边界上拆分而不删除任何字符？
"abc11def22ghi".split(/?/) = ["abc","11","def","22","ghi"];
或者是否有另一种比较不涉及拆分的字符串的方法，可能是通过用前导零填充所有数字组，使它们的长度相同？
"aa1bb" => "aa00000001bb", "aa10bb" => "aa00000010bb"
我正在处理任意字符串，而不是具有特定数字组排列的字符串。
编辑：
我喜欢Gaby的/(\d+)/一个班轮来拆分阵列。如何向后兼容？
以可用于重建原始文件的方式解析字符串一次的解决方案比此比较函数更有效。没有任何答案处理一些以数字开头的字符串而其他字符串不处理，但这很容易补救，并且在原始问题中没有明确说明。
["a100","a20","a3","a3b","a3b100","a3b20","a3b3","!!","~~","9","10","9.5"].sort( function ( inA , inB ) {
var result = 0;
var a , b , pattern = /(\d+)/;
var as = inA.split( pattern );
var bs = inB.split( pattern );
var index , count = as.length;
if ( ( '' === as[0] ) === ( '' === bs[0] ) ) {
if ( count > bs.length ) count = bs.length;
for ( index = 0 ; index < count && 0 === result ; ++index ) {
a = as[index]; b = bs[index];
if ( index & 1 ) {
result = a - b;
} else {
result = !( a < b ) ? ( a > b ) ? 1 : 0 : -1;
}
}
if ( 0 === result ) result = as.length - bs.length;
} else {
result = !( inA < inB ) ? ( inA > inB ) ? 1 : 0 : -1;
}
return result;
} ).toString();
结果："!!,9,9.5,10,a3,a3b,a3b3,a3b20,a3b100,a20,a100,~~"
答案 0 :(得分：15)
我认为这可以做你想要的事情
function sortArray(arr) {
var tempArr = [], n;
for (var i in arr) {
tempArr[i] = arr[i].match(/([^0-9]+)|([0-9]+)/g);
for (var j in tempArr[i]) {
if( ! isNaN(n = parseInt(tempArr[i][j])) ){
tempArr[i][j] = n;
}
}
}
tempArr.sort(function (x, y) {
for (var i in x) {
if (y.length < i || x[i] < y[i]) {
return -1; // x is longer
}
if (x[i] > y[i]) {
return 1;
}
}
return 0;
});
for (var i in tempArr) {
arr[i] = tempArr[i].join('');
}
return arr;
}
alert(
sortArray(["a1b3", "a10b11", "a10b2", "a9b2"]).join(",")
);
答案 1 :(得分：6)
使用此比较功能进行排序..
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;
}
语法
var data = ["a1b3","a10b11","b10b2","a9b2","a1b20","a1c4"];
data.sort( compareLists );
alert(data);
答案 2 :(得分：5)
假设你想要做的只是按每个数组条目中的数字进行数字排序（忽略非数字），你可以使用：
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);
}
它使用自定义排序功能，删除数字并在每次要求进行比较时转换为数字。你可以在这里看到它：http://jsfiddle.net/jfriend00/t87m2/。
如果这不是你想要的，那么请澄清，因为你的问题不是很清楚，这种排序应该真正有效。
答案 3 :(得分：3)
另一个变体是使用带有数字选项的Intl.Collator实例：
var array = ["a100","a20","a3","a3b","a3b100","a3b20","a3b3","!!","~~","9","10","9.5"];
var collator = new Intl.Collator(undefined, {numeric: true});
array.sort((a, b) => collator.compare(a, b));
console.log(array);
答案 4 :(得分：1)
Here's a more complete solution根据字符串中的字母和数字进行排序
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;
}
答案 5 :(得分：0)
除非您创建自定义算法，否则从左到右进行排序。字母或数字首先比较数字然后是字母。
但是，根据您自己的示例（a1，a9，a10）您想要实现的目标不会发生。这将要求你在掌握之前知道数据并在应用排序之前以各种可能的方式拆分字符串。
最后一种选择是：
a）每当从一个字母到另一个数字的变化时，从左到右打破每个字符串，反之亦然; ＆安培; b）然后从RIGHT-TO-LEFT开始对这些组进行排序。这将是一个非常苛刻的算法。可以做到！
最后，如果你是原始“文本”的发生器，你应该考虑将a1 a9 a10输出为a01 a09 a10的输出正常化。通过这种方式，您可以获得算法最终版本的完整信息。
祝你好运！答案 6 :(得分：0)
我需要一种方法来获取一个混合字符串并创建一个可以在其他地方排序的字符串，以便数字按字母顺序排列数字和字母。根据上面的答案，我创建了以下内容，以我能理解的方式填写所有数字，无论它们出现在字符串中的哪个位置。
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;
}