JavaScript不区分大小写的字符串比较-Java 学习之路

801

如何在JavaScript中执行不区分大小写的字符串比较？

18 回答

106
最简单的方法（如果你不担心特殊的Unicode字符）是调用 toUpperCase ：
```
var areEqual = string1.toUpperCase() === string2.toUpperCase();
```
回复于 2024-04-19T05:35:45+08:00
1

EDIT ：这个答案是7岁 . 今天你应该使用localeCompare .

原始答案

在JavaScript中进行不区分大小写的比较的最佳方法是使用RegExp match（）方法和'i'标志 .

JavaScript: case-insensitive search

当比较的两个字符串都是变量（不是常量）时，它会有点复杂'因为你需要从字符串生成一个RegExp但是将字符串传递给RegExp构造函数会导致错误的匹配或失败的匹配如果字符串有特殊的正则表达式其中的人物 .

如果您关心国际化，请不要使用toLowerCase（）或toUpperCase（），因为它不能在所有语言中提供准确的不区分大小写的比较 .

http://www.i18nguy.com/unicode/turkish-i18n.html

回复于 2024-04-19T05:35:45+08:00
0
在正则表达式的帮助下我们也可以实现 .
```
(/keyword/i).test(source)
```
/i 用于忽略大小写 . 如果没有必要，我们可以忽略并测试NOT区分大小写的匹配
```
(/keyword/).test(source)
```
回复于 2024-04-19T05:35:45+08:00
26
请记住，大小写是特定于语言环境的操作 . 根据具体情况，您可能希望将其纳入帐户 . 例如，如果要比较两个人的名字，可能需要考虑区域设置，但如果要比较机器生成的值（如UUID），则可能不会 . 这就是为什么我在我的utils库中使用以下函数（请注意，出于性能原因，不包括类型检查） .
```
function compareStrings (string1, string2, ignoreCase, useLocale) {
    if (ignoreCase) {
        if (useLocale) {
            string1 = string1.toLocaleLowerCase();
            string2 = string2.toLocaleLowerCase();
        }
        else {
            string1 = string1.toLowerCase();
            string2 = string2.toLowerCase();
        }
    }

    return string1 === string2;
}
```
回复于 2024-04-19T05:35:45+08:00
25
如果你担心不等式的方向（也许你想要对列表进行排序），你几乎必须进行大小写转换，因为unicode中的小写字符比大写toLowerCase更多可能是最好的转换 .
```
function my_strcasecmp( a, b ) 
{
    if((a+'').toLowerCase() > (b+'').toLowerCase()) return 1  
    if((a+'').toLowerCase() < (b+'').toLowerCase()) return -1
    return 0
}
```
Javascript似乎使用区域设置“C”进行字符串比较，因此如果字符串包含非ASCII字母，则生成的顺序将是丑陋的 . 如果不对字符串进行更详细的检查，就没有太多可以做的事情 .
回复于 2024-04-19T05:35:45+08:00

我最近创建了一个提供不区分大小写的字符串帮助程序的微库：https://github.com/nickuraltsev/ignore-case . （它在内部使用 toUpperCase . ）

var ignoreCase = require('ignore-case');

ignoreCase.equals('FOO', 'Foo'); // => true
ignoreCase.startsWith('foobar', 'FOO'); // => true
ignoreCase.endsWith('foobar', 'BaR'); // => true
ignoreCase.includes('AbCd', 'c'); // => true
ignoreCase.indexOf('AbCd', 'c'); // => 2

回复于 2024-04-19T05:35:45+08:00

2
正如最近的评论所说，string::localCompare支持不区分大小写的比较（以及其他强大的东西） .

这是一个简单的例子
```
'xyz'.localeCompare('XyZ', undefined, { sensitivity: 'base' }); // returns 0
```
还有一个你可以使用的通用功能
```
function equalsIgnoringCase(text, other) {
    text.localeCompare(other, undefined, { sensitivity: 'base' }) === 0;
}
```
请注意，您应该输入您正在使用的特定区域设置，而不是 undefined . 这很重要，如MDN文档中所述

瑞典语，ä和a是单独的基本字母

灵敏度选项

浏览器支持

截至发布时，UC浏览器Android和Opera Mini不支持区域设置和选项参数 . 请查看https://caniuse.com/#search=localeCompare以获取最新信息 .
回复于 2024-04-19T05:35:45+08:00
5
假设我们想在字符串变量 haystack 中找到字符串变量 needle . 有三个问题：
- 国际化应用程序应避免 string.toUpperCase 和 string.toLowerCase . 使用忽略大小写的正则表达式 . 例如， var needleRegExp = new RegExp(needle, "i"); 后跟 needleRegExp.test(haystack) .
- 通常，您可能不知道 needle 的值 . 请注意 needle 不包含任何正则表达式special characters . 使用 needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); 来逃避这些 .
- 在其他情况下，如果要精确匹配 needle 和 haystack ，只需忽略大小写，请确保在开头添加 "^" ，在正则表达式构造函数末尾添加 "$" .
考虑点（1）和（2），一个例子是：
```
var haystack = "A. BAIL. Of. Hay.";
var needle = "bail.";
var needleRegExp = new RegExp(needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "i");
var result = needleRegExp.test(haystack);
if (result) {
    // Your code here
}
```
回复于 2024-04-19T05:35:45+08:00
1
有两种不区分大小写的比较方法：
- 将字符串转换为大写，然后使用strict运算符（ === ）对它们进行比较 . 操作员如何严格阅读操作数：http://www.thesstech.com/javascript/relational-logical-operators
- 使用字符串方法匹配模式：
使用"search"字符串方法进行不区分大小写的搜索 . 阅读有关搜索和其他字符串方法的信息：http://www.thesstech.com/pattern-matching-using-string-methods
```
<!doctype html>
  <html>
    <head>
      <script>

        // 1st way

        var a = "apple";
        var b = "APPLE";  
        if (a.toUpperCase() === b.toUpperCase()) {
          alert("equal");
        }

        //2nd way

        var a = " Null and void";
        document.write(a.search(/null/i)); 

      </script>
    </head>
</html>
```
回复于 2024-04-19T05:35:45+08:00

926

这里有很多答案，但我想添加一个基于扩展String lib的sollution：

String.prototype.equalIgnoreCase = function(str)
{
    return (str != null 
            && typeof str === 'string'
            && this.toUpperCase() === str.toUpperCase());
}

这样你可以像在Java中一样使用它！

例：

var a = "hello";
var b = "HeLLo";
var c = "world";

if (a.equalIgnoreCase(b)) {
    document.write("a == b");
}
if (a.equalIgnoreCase(c)) {
    document.write("a == c");
}
if (!b.equalIgnoreCase(c)) {
    document.write("b != c");
}

输出将是：

"a == b"
"b != c"

String.prototype.equalIgnoreCase = function(str) {
  return (str != null &&
    typeof str === 'string' &&
    this.toUpperCase() === str.toUpperCase());
}


var a = "hello";
var b = "HeLLo";
var c = "world";

if (a.equalIgnoreCase(b)) {
  document.write("a == b");
  document.write("<br>");
}
if (a.equalIgnoreCase(c)) {
  document.write("a == c");
}
if (!b.equalIgnoreCase(c)) {
  document.write("b != c");
}

回复于 2024-04-19T05:35:45+08:00

str = 'Lol', str2 = 'lOl', regex = new RegExp('^' + str + '$', 'i');
if (regex.test(str)) {
    console.log("true");
}

回复于 2024-04-19T05:35:45+08:00

即使这个问题已经回答了 . 我有一个不同的方法来使用RegExp和匹配来忽略区分大小写 . 请看我的链接https://jsfiddle.net/marchdave/7v8bd7dq/27/

$("#btnGuess").click(guessWord);

  function guessWord() {

   var letter = $("#guessLetter").val();
   var word = 'ABC';
   var pattern = RegExp(letter, 'gi'); // pattern: /a/gi

   var result = word.match(pattern);
   alert('Ignore case sensitive:' + result);

  }

回复于 2024-04-19T05:35:45+08:00

如何不抛出异常而不使用慢速正则表达式？

return str1 != null && str2 != null 
    && typeof str1 === 'string' && typeof str2 === 'string'
    && str1.toUpperCase() === str2.toUpperCase();

如果任一字符串为null或未定义，上面的代码段假定您不希望匹配 .

如果要匹配null / undefined，则：

return (str1 == null && str2 == null)
    || (str1 != null && str2 != null 
        && typeof str1 === 'string' && typeof str2 === 'string'
        && str1.toUpperCase() === str2.toUpperCase());

如果由于某种原因你关心undefined vs null：

return (str1 === undefined && str2 === undefined)
    || (str1 === null && str2 === null)
    || (str1 != null && str2 != null 
        && typeof str1 === 'string' && typeof str2 === 'string'
        && str1.toUpperCase() === str2.toUpperCase());

回复于 2024-04-19T05:35:45+08:00

2
使用regix进行字符串匹配或比较，

in javaScript , you can use match() for string comparison , dont forget to put i in regix

例子：
```
var matchString = "Test" ;
if(matchString.match(/test/i) ){
  alert('String matched) ;
}else{
 alert('String not matched') ;
}
```
回复于 2024-04-19T05:35:45+08:00

我写了一个扩展名 . 很琐碎

if (typeof String.prototype.isEqual!= 'function') {
    String.prototype.isEqual = function (str){
        return this.toUpperCase()==str.toUpperCase();
     };
}

回复于 2024-04-19T05:35:45+08:00

4
由于没有答案清楚地提供了使用 RegExp 的简单代码片段，这里是我的尝试：
```
function compareInsensitive(str1, str2){ 
  return typeof str1 === 'string' && 
    typeof str2 === 'string' && 
    new RegExp("^" + str1.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') + "$", "i").test(str2);
}
```
它有几个优点：
- 验证参数类型（任何非字符串参数，例如 undefined ，都会使表达式崩溃，如 str1.toUpperCase() ） .
- 不受可能的国际化问题的影响 .
- 转义 RegExp 字符串 .
回复于 2024-04-19T05:35:45+08:00
1
如果两个字符串具有相同的已知语言环境，则可能需要使用Intl.Collator对象，如下所示：
```
function equalIgnoreCase(s1: string, s2: string) {
    return new Intl.Collator("en-US", { sensitivity: "base" }).compare(s1, s2) === 0;
}
```
显然，您可能希望缓存 Collator 以获得更高的效率 .

这种方法的优点是它应该比使用RegExps快得多，并且基于一组非常可定制的（参见上面文章中的 locales 和 options 构造函数参数的描述）一套即用型整理器 .
回复于 2024-04-19T05:35:45+08:00

这是this answer的 improved version .

String.equal = function (s1, s2, ignoreCase, useLocale) {
    if (s1 == null || s2 == null)
        return false;

    if (!ignoreCase) {
        if (s1.length !== s2.length)
            return false;

        return s1 === s2;
    }

    if (useLocale) {
        if (useLocale.length)
            return s1.toLocaleLowerCase(useLocale) === s2.toLocaleLowerCase(useLocale)
        else
            return s1.toLocaleLowerCase() === s2.toLocaleLowerCase()
    }
    else {
        if (s1.length !== s2.length)
            return false;

        return s1.toLowerCase() === s2.toLowerCase();
    }
}

Usages & tests:

String.equal = function (s1, s2, ignoreCase, useLocale) {
    if (s1 == null || s2 == null)
        return false;

    if (!ignoreCase) {
        if (s1.length !== s2.length)
            return false;

        return s1 === s2;
    }

    if (useLocale) {
        if (useLocale.length)
            return s1.toLocaleLowerCase(useLocale) === s2.toLocaleLowerCase(useLocale)
        else
            return s1.toLocaleLowerCase() === s2.toLocaleLowerCase()
    }
    else {
        if (s1.length !== s2.length)
            return false;

        return s1.toLowerCase() === s2.toLowerCase();
    }
}

// If you don't mind extending the prototype.
String.prototype.equal = function(string2, ignoreCase, useLocale) {
  return String.equal(this.valueOf(), string2, ignoreCase, useLocale);
}

// ------------------ TESTS ----------------------
console.log("Tests...");

console.log('Case sensitive 1');
var result = "Abc123".equal("Abc123");
console.assert(result === true);

console.log('Case sensitive 2');
result = "aBC123".equal("Abc123");
console.assert(result === false);

console.log('Ignore case');
result = "AbC123".equal("aBc123", true);
console.assert(result === true);

console.log('Ignore case + Current locale');
result = "AbC123".equal("aBc123", true);
console.assert(result === true);

console.log('Turkish test 1 (ignore case, en-US)');
result = "IiiI".equal("ıiİI", true, "en-US");
console.assert(result === false);

console.log('Turkish test 2 (ignore case, tr-TR)');
result = "IiiI".equal("ıiİI", true, "tr-TR");
console.assert(result === true);

console.log('Turkish test 3 (case sensitive, tr-TR)');
result = "IiiI".equal("ıiİI", false, "tr-TR");
console.assert(result === false);

console.log('null-test-1');
result = "AAA".equal(null);
console.assert(result === false);

console.log('null-test-2');
result = String.equal(null, "BBB");
console.assert(result === false);

console.log('null-test-3');
result = String.equal(null, null);
console.assert(result === false);

回复于 2024-04-19T05:35:45+08:00

JavaScript不区分大小写的字符串比较

18 回答

灵敏度选项

浏览器支持

相关问题