如何在 JavaScript 中执行不区分大小写的字符串排序数组？

Question

我有一个字符串数组，需要在 JavaScript 中排序，但不区分大小写。如何执行此操作？

Answer 1

在（几乎：）单行

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

结果

[ 'bar', 'Foo' ]

虽然

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

结果

[ 'Foo', 'bar' ]

Answer 2

是时候重新审视这个老问题了。

您不应使用依赖于toLowerCase 的解决方案。它们效率低下，并且在某些语言（例如土耳其语）中不起作用。喜欢这个：

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

查看documentation 以了解浏览器兼容性以及所有有关sensitivity 选项的信息。

Answer 3

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

编辑： 请注意，我最初写这篇文章是为了说明这项技术，而不是考虑到性能。另请参阅答案@Ivan Krechetov 以获得更紧凑的解决方案。

Answer 4

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

Answer 5

您还可以使用新的Intl.Collator().compare，在对数组进行排序时，根据 MDN，它是 more efficient。缺点是旧浏览器不支持它。 MDN 声明 Safari 根本不支持它。需要验证它，因为它声明支持Intl.Collator。

当比较大量字符串时，比如对大数组进行排序，最好创建一个 Intl.Collat​​or 对象，并使用它的 compare 属性提供的函数

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

Answer 6

如果你想保证相同的顺序而不管输入数组中元素的顺序，这里有一个stable排序：

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 7

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

Answer 8

用.toLowerCase() 规范化.sort() 中的情况。

Answer 9

您也可以使用 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 方法可能没问题...

注意：Elvis 运算符是 if then else 的缩写形式“三元运算符”，通常带有赋值。
如果你看 ?: 侧面，它看起来像猫王......
即代替：

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

你可以使用：

x = y?1:2;

即当 y 为真时，返回 1（赋值给 x），否则返回 2（赋值给 x）。

Answer 10

其他答案假设数组包含字符串。我的方法更好，因为即使数组包含 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 将在“nulk”和“nulm”之间排序。但undefined 将始终排在最后。

Answer 11

为了支持已接受的答案，我想补充一点，下面的函数似乎改变了要排序的原始数组中的值，因此它不仅会对小写进行排序，而且大写的值也会更改为小写.这对我来说是个问题，因为即使我希望看到 Mary 紧挨着 Mary，我也不希望 Mary 的第一个值的大小写更改为小写。

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

Answer 12

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

Answer 13

如果您难以理解，这可能会有所帮助：

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 14

我将最佳答案包装在一个 polyfill 中，这样我就可以在字符串数组上调用 .sortIgnoreCase()

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

Answer 15

将您的字符串包装在/ /i 中。这是使用正则表达式忽略大小写的简单方法