regulares - Javascript: tipo natural de cadenas alfanuméricas

validar caracteres especiales javascript

Question

Estoy buscando la manera más fácil de ordenar una matriz que consta de números y texto, y una combinación de estos.

P.ej

''123asd''
''19asd''
''12345asd''
''asd123''
''asd12''

se convierte en

''19asd''
''123asd''
''12345asd''
''asd12''
''asd123''

Esto se usará en combinación con la solución a otra pregunta que hice aquí .

La función de clasificación en sí funciona, lo que necesito es una función que pueda decir que ''19asd'' es más pequeño que ''123asd''.

Estoy escribiendo esto en JavaScript.

Editar: como lo señaló adormitu , lo que estoy buscando es una función para la clasificación natural

Answer 1

¿Entonces necesitas un tipo natural ?

Si es así, quizás este guión de Brian Huisman basado en el trabajo de David Koelle sea ​​lo que necesites.

Parece que la solución de Brian Huisman ahora está alojada directamente en el blog de David Koelle:

• Las soluciones javascript de Brian Huisman
• Artículo de David Koelle sobre el tema

Answer 2

Esto ahora es posible en navegadores modernos usando localeCompare. Al pasar la opción numeric: true , reconocerá los números inteligentemente. Puede hacer mayúsculas y minúsculas utilizando la sensitivity: ''base'' . Probado en Chrome, Firefox e IE11.

Aquí hay un ejemplo. Devuelve 1 , lo que significa que 10 va después de 2:

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

Para el rendimiento cuando se ordenan grandes cantidades de cadenas, el artículo dice:

Al comparar grandes cantidades de cadenas, como en la ordenación de matrices grandes, es mejor crear un objeto Intl.Collator y utilizar la función proporcionada por su propiedad de comparación. Enlace de documentos

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

Answer 3

Imagine una función de relleno de 8 dígitos que transforma:

• ''123asd'' -> ''00000123asd''
• ''19asd'' -> ''00000019asd''

Podemos usar las cadenas acolchadas para ayudarnos a ordenar ''19asd'' para que aparezca antes de ''123asd''.

Use la expresión regular //d+/g para ayudar a encontrar todos los números que deben rellenarse:

str.replace(//d+/g, pad)

A continuación se muestra la clasificación usando esta técnica:

var list = [
''123asd'',
''19asd'',
''12345asd'',
''asd123'',
''asd12''
];
function pad(n) { return ("00000000" + n).substr(-8); }
function natural_expand(a) { return a.replace(//d+/g, pad) };
function natural_compare(a, b) {
return natural_expand(a).localeCompare(natural_expand(b));
}
console.log(list.map(natural_expand).sort()); // intermediate values
console.log(list.sort(natural_compare)); // result

Los resultados intermedios muestran lo que hace la rutina natural_expand () y le da una comprensión de cómo funcionará la siguiente rutina natural_compare:

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

Productos:

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

Answer 4

Para comparar valores, puede usar un método de comparación:

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;
}

Pero para agilizar la ordenación de una matriz, arme la matriz antes de ordenar, por lo que solo tiene que hacer conversiones en minúsculas y la expresión regular una vez en lugar de en cada paso de la ordenación.

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];
}
}

Answer 5

Sobre la base de la respuesta de @Adrien Be y utilizando el código creado por Brian Huisman y David Koelle , aquí hay una clasificación de prototipo modificado para una variedad de objetos:

//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"];
}
}