自然排序的字母数字字符串

小开

要比较值，您可以使用比较方法-

function naturalSorter(as, bs){
var a, b, a1, b1, i= 0, n, L,
rx=/(\.\d+)|(\d+(\.\d+)?)|([^\d.]+)|(\.\D+)|(\.$)/g;
if(as=== bs) return 0;
a= as.toLowerCase().match(rx);
b= bs.toLowerCase().match(rx);
L= a.length;
while(i<L){
if(!b[i]) return 1;
a1= a[i],
b1= b[i++];
if(a1!== b1){
n= a1-b1;
if(!isNaN(n)) return n;
return a1>b1? 1:-1;
}
}
return b[i]? -1:0;
}

但是为了加快排序数组的速度，在排序之前先对数组进行操作，所以你只需要做小写转换和正则表达式

function naturalSort(ar, index){
var L= ar.length, i, who, next,
isi= typeof index== 'number',
rx=  /(\.\d+)|(\d+(\.\d+)?)|([^\d.]+)|(\.(\D+|$))/g;
function nSort(aa, bb){
var a= aa[0], b= bb[0], a1, b1, i= 0, n, L= a.length;
while(i<L){
if(!b[i]) return 1;
a1= a[i];
b1= b[i++];
if(a1!== b1){
n= a1-b1;
if(!isNaN(n)) return n;
return a1>b1? 1: -1;
}
}
return b[i]!= undefined? -1: 0;
}
for(i= 0; i<L; i++){
who= ar[i];
next= isi? ar[i][index] || '': who;
ar[i]= [String(next).toLowerCase().match(rx), who];
}
ar.sort(nSort);
for(i= 0; i<L; i++){
ar[i]= ar[i][1];
}
}

小开

最佳答案

在使用localeCompare的现代浏览器中，这是可能的。通过传递numeric: true选项，它将聪明地识别数字。你可以使用sensitivity: 'base'来做到不区分大小写。在Chrome, Firefox和IE11中测试。

举个例子。它返回1，这意味着2后面是10:

'10'.localeCompare('2', undefined, {numeric: true, sensitivity: 'base'})

为了提高对大量字符串进行排序时的性能，本文说:

当比较大量字符串时，例如对大型数组排序时，最好创建Intl。对象，并使用其compare属性提供的函数。文档链接

var collator = new Intl.Collator(undefined, {numeric: true, sensitivity: 'base'});
var myArray = ['1_Document', '11_Document', '2_Document'];
console.log(myArray.sort(collator.compare));

小开

基于上面@Adrien Be的回答，并使用布莱恩·豪氏威马 &大卫koelle创建后，下面是一个修改过的对象数组排序原型:

//Usage: unsortedArrayOfObjects.alphaNumObjectSort("name");
//Test Case: var unsortedArrayOfObjects = [{name: "a1"}, {name: "a2"}, {name: "a3"}, {name: "a10"}, {name: "a5"}, {name: "a13"}, {name: "a20"}, {name: "a8"}, {name: "8b7uaf5q11"}];
//Sorted: [{name: "8b7uaf5q11"}, {name: "a1"}, {name: "a2"}, {name: "a3"}, {name: "a5"}, {name: "a8"}, {name: "a10"}, {name: "a13"}, {name: "a20"}]


// **Sorts in place**
Array.prototype.alphaNumObjectSort = function(attribute, caseInsensitive) {
for (var z = 0, t; t = this[z]; z++) {
this[z].sortArray = new Array();
var x = 0, y = -1, n = 0, i, j;


while (i = (j = t[attribute].charAt(x++)).charCodeAt(0)) {
var m = (i == 46 || (i >=48 && i <= 57));
if (m !== n) {
this[z].sortArray[++y] = "";
n = m;
}
this[z].sortArray[y] += j;
}
}


this.sort(function(a, b) {
for (var x = 0, aa, bb; (aa = a.sortArray[x]) && (bb = b.sortArray[x]); x++) {
if (caseInsensitive) {
aa = aa.toLowerCase();
bb = bb.toLowerCase();
}
if (aa !== bb) {
var c = Number(aa), d = Number(bb);
if (c == aa && d == bb) {
return c - d;
} else {
return (aa > bb) ? 1 : -1;
}
}
}


return a.sortArray.length - b.sortArray.length;
});


for (var z = 0; z < this.length; z++) {
// Here we're deleting the unused "sortArray" instead of joining the string parts
delete this[z]["sortArray"];
}
}

小开

想象一个数字0填充函数n => n.padStart(8, "0")，它接受任何数字并填充它，即。

“19”;→“00000019”;
“123”;→“00000123”;

此函数可用于帮助对"19"字符串进行排序，使其出现在"123"字符串之前。

让我们添加一个正则表达式/\d+/g，创建自然展开函数str => str.replace(/\d+/g, n => n.padStart(8, "0"))，它只找到字符串中的数字部分并填充它们，即。

“19 asd"→“00000019 asd"
“123 asd"→“00000123 asd"

现在，我们可以使用这个自然展开函数来帮助实现自然排序:

const list = [
"123asd",
"19asd",
"12345asd",
"asd123",
"asd12"
];


const ne = str => str.replace(/\d+/g, n => n.padStart(8, "0"));
const nc = (a,b) => ne(a).localeCompare(ne(b));


console.log(list.map(ne).sort()); // intermediate values
console.log(list.sort(nc)); // result

由list.map(ne).sort()演示的中间结果显示了ne自然展开函数的作用。它只对字符串的数字部分实现数字0填充，而字母表组件保持不变。

[
"00000019asd",
"00000123asd",
"00012345asd",
"asd00000012",
"asd00000123"
]

解决方案的最终版本实现了一个自然顺序比较器nc，实现为(a,b) => ne(a).localeCompare(ne(b))，并在list.sort(nc)中使用它，以便正确地排序:

[
"19asd",
"123asd",
"12345asd",
"asd12",
"asd123"
]

小开

如果你有一个对象数组，你可以这样做:

myArrayObjects = myArrayObjects.sort(function(a, b) {
return a.name.localeCompare(b.name, undefined, {
numeric: true,
sensitivity: 'base'
});
});

var myArrayObjects = [{
"id": 1,
"name": "1 example"
},
{
"id": 2,
"name": "100 example"
},
{
"id": 3,
"name": "12 example"
},
{
"id": 4,
"name": "5 example"
},


]


myArrayObjects = myArrayObjects.sort(function(a, b) {
return a.name.localeCompare(b.name, undefined, {
numeric: true,
sensitivity: 'base'
});
});
console.log(myArrayObjects);

小开

截至2019年，功能最齐全的处理此问题的库似乎是natural-orderby。

import { orderBy } from 'natural-orderby'


const unordered = [
'123asd',
'19asd',
'12345asd',
'asd123',
'asd12'
]


const ordered = orderBy(unordered)


// [ '19asd',
//   '123asd',
//   '12345asd',
//   'asd12',
//   'asd123' ]

它不仅接受字符串数组，而且还可以根据对象数组中某个键的值进行排序。它还可以自动识别和排序字符串:货币、日期、货币和其他一堆东西。

令人惊讶的是，当gzip时，它也只有1.6kB。