Làm cách nào để thực hiện phân loại không phân biệt chữ hoa chữ thường trong JavaScript?

Tôi có một chuỗi các chuỗi tôi cần sắp xếp trong JavaScript, nhưng theo cách không phân biệt chữ hoa chữ thường. Làm thế nào để thực hiện điều này?

Trong (gần như :) một lót

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

Kết quả nào

[ 'bar', 'Foo' ]

Trong khi

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

kết quả trong

[ 'Foo', 'bar' ]

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

EDIT: Xin lưu ý rằng ban đầu tôi đã viết điều này để minh họa cho kỹ thuật hơn là có hiệu suất trong tâm trí. Vui lòng tham khảo câu trả lời @Ivan Krechetov để có giải pháp nhỏ gọn hơn.

Đã đến lúc xem lại câu hỏi cũ này.

Bạn không nên sử dụng các giải pháp dựa vào toLowerCase. Chúng không hiệu quả và đơn giản là không hoạt động trong một số ngôn ngữ (ví dụ tiếng Thổ Nhĩ Kỳ). Thích điều này:

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

Kiểm tra tài liệu về tính tương thích của trình duyệt và tất cả những điều cần biết về sensitivitytùy chọn này.

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

Bạn cũng có thể sử dụng mới Intl.Collator().compare, trên mỗi MDN, nó hiệu quả hơn khi sắp xếp các mảng. Nhược điểm là nó không được hỗ trợ bởi các trình duyệt cũ hơn. MDN tuyên bố rằng nó hoàn toàn không được hỗ trợ trong Safari. Cần xác minh nó, vì nó nói rằng Intl.Collatorđược hỗ trợ.

Khi so sánh số lượng lớn các chuỗi, chẳng hạn như trong việc sắp xếp các mảng lớn, tốt hơn là tạo một đối tượng Intl.Collator và sử dụng hàm được cung cấp bởi thuộc tính so sánh của nó

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

Nếu bạn muốn đảm bảo cùng một thứ tự bất kể thứ tự các phần tử trong mảng đầu vào, đây là cách sắp xếp ổn định :

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

Bình thường hóa trường hợp trong .sort()với .toLowerCase().

Bạn cũng có thể sử dụng toán tử 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);

Cung cấp:

biscuit,Bob,charley,fudge,Fudge

Phương thức localeCompare có lẽ vẫn ổn mặc dù ...

Lưu ý: Toán tử Elvis là một dạng "toán tử ternary" dạng ngắn, nếu sau đó, thường là với phép gán.
Nếu bạn nhìn vào ?: Đi ngang, có vẻ như Elvis ...
tức là thay vì:

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

bạn có thể dùng:

x = y?1:2;

tức là khi y đúng, sau đó trả về 1 (đối với gán cho x), nếu không thì trả về 2 (đối với gán cho x).

Các câu trả lời khác cho rằng mảng chứa chuỗi. Phương thức của tôi tốt hơn, bởi vì nó sẽ hoạt động ngay cả khi mảng chứa null, không xác định hoặc các chuỗi không khác.

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

Các nullsẽ được sắp xếp giữa 'nulk' và 'nulm'. Nhưng undefinedsẽ luôn luôn được sắp xếp cuối cùng.

Phiên bản ES6:

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

Nguồn: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare

Để hỗ trợ cho câu trả lời được chấp nhận, tôi muốn thêm rằng hàm bên dưới dường như thay đổi các giá trị trong mảng ban đầu được sắp xếp để không chỉ sắp xếp chữ thường mà các giá trị chữ hoa cũng sẽ được thay đổi thành chữ thường. Đây là một vấn đề đối với tôi bởi vì mặc dù tôi muốn thấy Mary bên cạnh mary, tôi không muốn rằng trường hợp của giá trị đầu tiên Mary được thay đổi thành chữ thường.

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

Trong các thí nghiệm của tôi, hàm sau từ câu trả lời được chấp nhận sắp xếp chính xác nhưng không thay đổi các giá trị.

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

Điều này có thể giúp đỡ nếu bạn đã đấu tranh để hiểu:

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/

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

Trong hàm trên, nếu chúng ta chỉ so sánh khi chữ thường hai giá trị a và b, chúng ta sẽ không có kết quả đẹp.

Ví dụ, nếu mảng là [A, a, B, b, c, C, D, d, e, E] và chúng tôi sử dụng hàm trên, chúng tôi có chính xác mảng đó. Nó không thay đổi gì cả.

Để có kết quả là [A, a, B, b, C, c, D, d, E, e], chúng ta nên so sánh lại khi hai giá trị chữ thường bằng nhau:

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

Tôi gói câu trả lời hàng đầu trong một polyfill để tôi có thể gọi .sortIgnoreCase () trên mảng chuỗi

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

Quấn dây của bạn vào / /i. Đây là một cách dễ dàng để sử dụng regex để bỏ qua vỏ