Как выполнить сортировку без учета регистра в JavaScript?

У меня есть массив строк, которые мне нужно отсортировать в JavaScript, но без учета регистра. Как это сделать?

В (почти :) один вкладыш

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

Что приводит к

[ 'bar', 'Foo' ]

Пока

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

результаты в

[ 'Foo', 'bar' ]

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

РЕДАКТИРОВАТЬ: Обратите внимание, что я изначально написал это, чтобы проиллюстрировать технику, а не иметь в виду производительность. Пожалуйста, также обратитесь к ответу @Ivan Krechetov для более компактного решения.

Настало время вернуться к этому старому вопросу.

Вы не должны использовать решения, основанные на toLowerCase. Они неэффективны и просто не работают на некоторых языках (например, на турецком). Предпочитаю это:

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

Проверьте документацию на совместимость браузера и все, что нужно знать об этой sensitivityопции.

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

Вы также можете использовать новый Intl.Collator().compare, согласно MDN, он более эффективен при сортировке массивов. Недостатком является то, что он не поддерживается старыми браузерами. MDN заявляет, что он вообще не поддерживается в Safari. Нужно проверить это, так как в нем говорится, что Intl.Collatorподдерживается.

При сравнении большого количества строк, например при сортировке больших массивов, лучше создать объект Intl.Collator и использовать функцию, предоставляемую его свойством сравнения.

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

Если вы хотите гарантировать один и тот же порядок независимо от порядка элементов во входном массиве, вот стабильная сортировка:

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

Нормализовать регистр в .sort()с .toLowerCase().

Вы также можете использовать оператор 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);

дает:

biscuit,Bob,charley,fudge,Fudge

Метод localeCompare, вероятно, хорошо, хотя ...

Примечание. Оператор Элвиса - это краткая форма «троичный оператор», если не всегда, обычно с присваиванием.
Если вы посмотрите на?: Sideway, это будет похоже на Элвиса ...
т.е. вместо:

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

ты можешь использовать:

x = y?1:2;

т.е. когда y истинно, тогда возвращают 1 (для присваивания x), иначе возвращают 2 (для присваивания x).

Другие ответы предполагают, что массив содержит строки. Мой метод лучше, потому что он будет работать, даже если массив содержит null, undefined или другие нестандартные значения.

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

nullБудет отсортирован между «Нульк» и «nulm». Но последний всегдаundefined будет отсортирован.

Версия ES6:

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

Источник: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare

В поддержку принятого ответа я хотел бы добавить, что приведенная ниже функция, по-видимому, изменяет значения в исходном массиве для сортировки, так что она не только сортирует нижний регистр, но и значения верхнего регистра также изменяются на нижний регистр. Это проблема для меня, потому что хотя я хочу видеть Мэри рядом с Мэри, я не хочу, чтобы регистр первого значения Мэри был изменен на нижний регистр.

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

В моих экспериментах следующая функция из принятого ответа сортирует правильно, но не меняет значения.

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

Это может помочь, если вы пытались понять:

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

В приведенной выше функции, если мы просто сравниваем в нижнем регистре два значения a и b, мы не получим симпатичного результата.

Например, если массив [A, a, B, b, c, C, D, d, e, E] и мы используем вышеупомянутую функцию, у нас есть именно этот массив. Это ничего не изменило.

Чтобы получить результат [A, a, B, b, C, c, D, d, E, e], мы должны снова сравнить, когда два строчных значения равны:

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

Я завернул верхний ответ в полизаполнение, чтобы я мог вызвать .sortIgnoreCase () для строковых массивов

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

Оберните свои строки в / /i. Это простой способ использовать регулярные выражения, чтобы игнорировать обсадную колонну