Jak przeprowadzić sortowanie niewrażliwe na wielkość liter w JavaScript?

Question

Mam tablicę ciągów, które muszę sortować w JavaScript, ale w sposób niewrażliwy na wielkość liter. Jak to wykonać?

Answer 1

W (prawie :) one-liner

["Foo", "bar"].sort(function (a, b) { 
    return a.toLowerCase().localeCompare(b.toLowerCase()); 
}); 

co skutkuje

[ 'bar', 'Foo' ] 

podczas

["Foo", "bar"].sort(); 

wyników w

[ 'Foo', 'bar' ] 

Answer 2

Normalizacja obudowy w .sort() z .toLowerCase().

Answer 3

arr.sort(function(a,b) { 
    a = a.toLowerCase(); 
    b = b.toLowerCase(); 
    if (a == b) return 0; 
    if (a > b) return 1; 
    return -1; 
}); 

Answer 4

myArray.sort(
    function(a, b) { 
    if (a.toLowerCase() < b.toLowerCase()) return -1; 
    if (a.toLowerCase() > b.toLowerCase()) return 1; 
    return 0; 
    } 
); 

EDIT: Należy pamiętać, że pierwotnie napisałem to, aby zilustrować technikę zamiast wydajność w umyśle. Proszę również zapoznać się z odpowiedzią @Ivan Krechetov dla bardziej zwartego rozwiązania.

Answer 5

Jeśli chcesz, aby zapewnić taką samą kolejność niezależnie od kolejności elementów tablicy wejściowej, tutaj jest stable Sortowanie:

myArray.sort(function(a, b) { 
    /* Storing case insensitive comparison */ 
    var comparison = a.toLowerCase().localeCompare(b.toLowerCase()); 
    /* If strings are equal in case insensitive comparison */ 
    if (comparison === 0) { 
     /* Return case sensitive comparison instead */ 
     return a.localeCompare(b); 
    } 
    /* Otherwise return result */ 
    return comparison; 
}); 

Answer 6

Można również użyć operatora Elvis:

arr = ['Bob', 'charley', 'fudge', 'Fudge', 'biscuit']; 
arr.sort(function(s1, s2){ 
    var l=s1.toLowerCase(), m=s2.toLowerCase(); 
    return l===m?0:l>m?1:-1; 
}); 
console.log(arr); 

daje :

biscuit,Bob,charley,fudge,Fudge 

Sposób localeCompare jest chyba w porządku, chociaż ...

Uwaga: Operator Elvis jest krótką formą "operatora trójskładnikowego", jeśli jeszcze, zwykle z przydziałem.
Jeśli spojrzeć na: bokiem, wygląda jak Elvis ...
czyli zamiast:

if (y) { 
    x = 1; 
} else { 
    x = 2; 
} 

można użyć:

x = y?1:2; 

tj gdy y jest prawdą, a następnie return 1 (dla przypisania do x), w przeciwnym razie zwraca 2 (dla przypisania do x).

Answer 7

To może pomóc, jeśli starali się zrozumieć:

var array = ["sort", "Me", "alphabetically", "But", "Ignore", "case"]; 
console.log('Unordered array ---', array, '------------'); 

array.sort(function(a,b) { 
    a = a.toLowerCase(); 
    b = b.toLowerCase(); 
    console.log("Compare '" + a + "' and '" + b + "'"); 

    if(a == b) { 
     console.log('Comparison result, 0 --- leave as is '); 
     return 0; 
    } 
    if(a > b) { 
     console.log('Comparison result, 1 --- move '+b+' to before '+a+' '); 
     return 1; 
    } 
    console.log('Comparison result, -1 --- move '+a+' to before '+b+' '); 
    return -1; 


}); 

console.log('Ordered array ---', array, '------------'); 


// return logic 

/*** 
If compareFunction(a, b) is less than 0, sort a to a lower index than b, i.e. a comes first. 
If compareFunction(a, b) returns 0, leave a and b unchanged with respect to each other, but sorted with respect to all different elements. Note: the ECMAscript standard does not guarantee this behaviour, and thus not all browsers (e.g. Mozilla versions dating back to at least 2003) respect this. 
If compareFunction(a, b) is greater than 0, sort b to a lower index than a. 
***/ 

http://jsfiddle.net/ianjamieson/wmxn2ram/1/

Answer 8

arr.sort(function(a,b) { 
    a = a.toLowerCase(); 
    b = b.toLowerCase(); 
    if(a == b) return 0; 
    if(a > b) return 1; 
    return -1; 
}); 

W powyższej funkcji, jeśli po prostu porównać gdy małe litery dwie wartości aib, nie będziemy mieli ładny wynik.

Przykład, jeśli tablica to [A, a, B, b, c, C, D, d, e, E] i używamy powyższej funkcji, mamy dokładnie tą tablicę. Nic nie zmienia.

Aby uzyskać wynik w [A, A, B, B, C, C, D, D, E, k], to należy porównać ponownie po dwóch dolna wartość przypadku jest równa:

function caseInsensitiveComparator(valueA, valueB) { 
    var valueALowerCase = valueA.toLowerCase(); 
    var valueBLowerCase = valueB.toLowerCase(); 

    if (valueALowerCase < valueBLowerCase) { 
     return -1; 
    } else if (valueALowerCase > valueBLowerCase) { 
     return 1; 
    } else { //valueALowerCase === valueBLowerCase 
     if (valueA < valueB) { 
      return -1; 
     } else if (valueA > valueB) { 
      return 1; 
     } else { 
      return 0; 
     } 
    } 
} 

Answer 9

Owiń swoje struny w / /i. Jest to łatwy sposób użycia regex do ignorowania obudowy

Answer 10

Pozostałe odpowiedzi zakładają, że tablica zawiera ciągi. Moja metoda jest lepsza, ponieważ zadziała, nawet jeśli tablica zawiera wartości null, undefined lub inne nie-łańcuchowe.

var notdefined; 
var myarray = ['a', 'c', null, notdefined, 'nulk', 'BYE', 'nulm']; 

myarray.sort(ignoreCase); 

alert(JSON.stringify(myarray)); // show the result 

function ignoreCase(a,b) { 
    return (''+a).toUpperCase() < (''+b).toUpperCase() ? -1 : 1; 
} 

The null zostaną posortowane między '' i 'nulk nulm'. Jednak undefined zawsze będzie sortowany jako ostatni.

Answer 11

Możesz także użyć nowego Intl.Collator().compare, na MDN to more efficient podczas sortowania tablic. Minusem jest to, że nie jest obsługiwany przez starsze przeglądarki. MDN stwierdza, że ​​nie jest w ogóle obsługiwane w Safari. Należy go zweryfikować, ponieważ stwierdza, że ​​obsługiwana jest wersja Intl.Collator.

When comparing large numbers of strings, such as in sorting large arrays, it is better to create an Intl.Collator object and use the function provided by its compare property

["Foo", "bar"].sort(Intl.Collator().compare); //["bar", "Foo"] 

Answer 12

ja owinięty górna odpowiedź w PolyFill więc mogę zadzwonić .sortIgnoreCase() na tablicach smyczkowych

// Array.sortIgnoreCase() polyfill 
if (!Array.prototype.sortIgnoreCase) { 
    Array.prototype.sortIgnoreCase = function() { 
     return this.sort(function (a, b) { 
      return a.toLowerCase().localeCompare(b.toLowerCase()); 
     }); 
    }; 
} 

Answer 13

To jest czas, aby ponownie ten stary pytanie.

Nie powinieneś używać rozwiązań polegających na toLowerCase. Są one nieefektywne i po prostu nie działają w niektórych językach (na przykład turecki). Wolę to:

['Foo', 'bar'].sort((a, b) => a.localeCompare(b, undefined, {sensitivity: 'base'})) 

Sprawdź documentation kompatybilności przeglądarki i wszystko, co trzeba wiedzieć na temat opcji sensitivity.