如何进行不区分大小写的字符串比较？

最简单的方法（如果您不担心特殊的 Unicode 字符）是调用 toUpperCase：

var areEqual = string1.toUpperCase() === string2.toUpperCase();

---

编辑：这个答案最初是 9 年前添加的。今天您应该将 localeCompare 与 sensitivity: 'accent' 选项一起使用：

function ciEquals(a, b) { return typeof a === 'string' && typeof b === 'string' ? a.localeCompare(b, undefined, { 敏感度: 'accent' }) === 0 : a === b; } console.log("'a' = 'a'?", ciEquals('a', 'a')); console.log("'AaA' = 'aAa'?", ciEquals('AaA', 'aAa')); console.log("'a' = 'á'?", ciEquals('a', 'á')); console.log("'a' = 'b'?", ciEquals('a', 'b'));

{ sensitivity: 'accent' } 告诉 localeCompare() 将相同基本字母的两个变体视为相同的除非它们具有不同的重音（如第三个示例中所示）。

或者，您可以使用 { sensitivity: 'base' }，它将两个字符视为等效，只要它们的基本字符相同（因此 A 将被视为等效于 á）。

注意 localeCompare 的第三个参数在 IE10 或更低版本或某些移动浏览器中不支持（请参阅上面链接页面上的兼容性图表），因此如果您需要支持这些浏览器，您将需要某种后备：

function ciEqualsInner(a, b) {
    return a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0;
}

function ciEquals(a, b) {
    if (typeof a !== 'string' || typeof b !== 'string') {
        return a === b;
    }

    //      v--- feature detection
    return ciEqualsInner('A', 'a')
        ? ciEqualsInner(a, b)
        : /*  fallback approach here  */;
}

原始答案

在 JavaScript 中进行不区分大小写比较的最佳方法是使用带有 i 标志的 RegExp match() 方法。

Case-insensitive search

当被比较的两个字符串都是变量（不是常量）时，它会稍微复杂一些，因为您需要从字符串生成 RegExp，但是如果字符串具有特殊的正则表达式，则将字符串传递给 RegExp 构造函数可能会导致不正确的匹配或匹配失败里面的人物。

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

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

---

正如最近的评论中所说，string::localeCompare 支持不区分大小写的比较（以及其他强大的功能）。

这是一个简单的例子

'xyz'.localeCompare('XyZ', undefined, { sensitivity: 'base' }); // returns 0

还有一个你可以使用的通用函数

function equalsIgnoringCase(text, other) {
    return text.localeCompare(other, undefined, { sensitivity: 'base' }) === 0;
}

请注意，您可能应该输入您正在使用的特定语言环境，而不是 undefined。正如 MDN 文档中所述，这很重要

在瑞典语中，ä 和 a 是独立的基本字母

灵敏度选项

https://i.stack.imgur.com/tTMud.png

浏览器支持

截至发稿时，适用于 Android 和 Opera Mini 的 UC 浏览器不支持 locale 和 options 参数。请查看 https://caniuse.com/#search=localeCompare 以获取最新信息。

---

更新：

根据评论，先前的答案检查 source contains keyword，使其相等检查添加 ^ 和 $。

(/^keyword$/i).test(source)

借助正则表达式我们也可以实现。

(/keyword/i).test(source)

/i 用于忽略大小写。如果没有必要，我们可以忽略并测试不区分大小写的匹配，例如

(/keyword/).test(source)

---

请记住，大小写是特定于语言环境的操作。根据情况，您可能需要考虑到这一点。例如，如果您要比较两个人的姓名，您可能需要考虑语言环境，但如果您要比较机器生成的值（例如 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;
}

---

如果您担心不等式的方向（也许您想对列表进行排序），则几乎必须进行大小写转换，并且由于 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 字母，则结果排序将很难看。如果不对琴弦进行更详细的检查，则无能为力。

---

我最近创建了一个提供不区分大小写的字符串助手的微型库：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

---

假设我们要在字符串变量 haystack 中找到字符串变量 needle。有三个陷阱：

国际化应用程序应避免使用 string.toUpperCase 和 string.toLowerCase。改用忽略大小写的正则表达式。例如， var needleRegExp = new RegExp(needle, "i");其次是 needleRegExp.test(haystack)。一般来说，您可能不知道针的价值。注意 needle 不包含任何正则表达式特殊字符。使用 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
}

---

这里有很多答案，但我喜欢添加一个基于扩展字符串库的解决方案：

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 = "你好"; var b = "你好"; var c = "世界"; if (a.equalIgnoreCase(b)) { document.write("a == b"); document.write("
"); } if (a.equalIgnoreCase(c)) { document.write("a == c"); } if (!b.equalIgnoreCase(c)) { document.write("b != c"); }

---

使用 RegEx 进行字符串匹配或比较。

在 JavaScript 中，您可以使用 match() 进行字符串比较，不要忘记将 i 放在 RegEx 中。

例子：

var matchString = "Test";
if (matchString.match(/test/i)) {
    alert('String matched');
}
else {
    alert('String not matched');
}

---

如果两个字符串都具有相同的已知语言环境，您可能希望像这样使用 Intl.Collator 对象：

function equalIgnoreCase(s1: string, s2: string) {
    return new Intl.Collator("en-US", { sensitivity: "base" }).compare(s1, s2) === 0;
}

显然，您可能希望缓存 Collator 以提高效率。

这种方法的优点是它应该比使用 RegExps 快得多，并且基于可高度定制的（参见上面文章中对 locales 和 options 构造函数参数的描述）一组即用型整理器。

---

不区分大小写的比较有两种方式：

将字符串转换为大写，然后使用严格运算符 (===) 进行比较。使用字符串方法进行模式匹配：

使用“搜索”字符串方法进行不区分大小写的搜索。

---

我喜欢这种快速的速记变化——

export const equalsIgnoreCase = (str1, str2) => {
    return (!str1 && !str2) || (str1 && str2 && str1.toUpperCase() == str2.toUpperCase())
}

处理速度快，并按预期进行。

---

我写了一个扩展。很琐碎

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

---

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

---

甚至这个问题也已经得到了回答。我有一种不同的方法来使用 RegExp 和 match 来忽略区分大小写。请看我的链接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);
}

---

将两者都转换为较低的字符串（出于性能原因仅一次）并将它们与内联三元运算符进行比较：

function strcasecmp(s1,s2){
    s1=(s1+'').toLowerCase();
    s2=(s2+'').toLowerCase();
    return s1>s2?1:(s1<s2?-1:0);
}

---

不抛出异常并且不使用慢正则表达式怎么样？

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

上面的代码片段假设如果字符串为空或未定义，您不想匹配。

如果要匹配 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());

---

由于没有答案清楚地提供了使用 RegExp 的简单代码段，因此这是我的尝试：

function compareInsensitive(str1, str2){ 
  return typeof str1 === 'string' && 
    typeof str2 === 'string' && 
    new RegExp("^" + str1.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') + "$", "i").test(str2);
}

它有几个优点：

验证参数类型（任何非字符串参数，例如 undefined，都会使 str1.toUpperCase() 等表达式崩溃）。不受可能的国际化问题的影响。转义 RegExp 字符串。

---

如果您知道您正在处理 ascii 文本，那么您可以使用大写/小写字符偏移比较。

只需确保您的“完美”字符串（您要匹配的字符串）为小写：

const CHARS_IN_BETWEEN = 32;
const LAST_UPPERCASE_CHAR = 90; // Z
function strMatchesIgnoreCase(lowercaseMatch, value) {
    let i = 0, matches = lowercaseMatch.length === value.length;
    while (matches && i < lowercaseMatch.length) {
        const a = lowercaseMatch.charCodeAt(i);
        const A = a - CHARS_IN_BETWEEN;
        const b = value.charCodeAt(i);
        const B = b + ((b > LAST_UPPERCASE_CHAR) ? -CHARS_IN_BETWEEN : CHARS_IN_BETWEEN);
        matches = a === b // lowerA === b
            || A === b // upperA == b
            || a === B // lowerA == ~b
            || A === B; // upperA == ~b
        i++;
    }
    return matches;
}

---

为了获得更好的浏览器兼容性，您可以依赖正则表达式。这将适用于过去 20 年发布的所有 Web 浏览器：

String.prototype.equalsci = function(s) {
    var regexp = RegExp("^"+this.replace(/[.\\+*?\[\^\]$(){}=!<>|:-]/g, "\\$&")+"$", "i");
    return regexp.test(s);
}

"PERSON@Ü.EXAMPLE.COM".equalsci("person@ü.example.com")// returns true

这与此处找到的其他答案不同，因为它考虑到并非所有用户都使用现代网络浏览器。

注意：如果您需要支持土耳其语等特殊情况，则需要使用 localeCompare，因为 i 和 I 在土耳其语中不是同一个字母。

"I".localeCompare("i", undefined, { sensitivity:"accent"})===0// returns true
"I".localeCompare("i", "tr", { sensitivity:"accent"})===0// returns false

---

这是 this answer 的改进版。

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

用法和测试：

String.equal = function (s1, s2, ignoreCase, useLocale) { if (s1 == null || s2 == null) return false; if (!ignoreCase) { if (s1.length !== s2.length) return false;返回 s1 === s2; } if (useLocale) { if (useLocale.length) return s1.toLocaleLowerCase(useLocale) === s2.toLocaleLowerCase(useLocale) else return s1.toLocaleLowerCase() === s2.toLocaleLowerCase() } else { if (s1.长度！== s2.length) 返回 false；返回 s1.toLowerCase() === s2.toLowerCase(); } } // 如果你不介意扩展原型。 String.prototype.equal = function(string2, ignoreCase, useLocale) { return String.equal(this.valueOf(), string2, ignoreCase, useLocale); } // ------------------ 测试 ---------- console.log("测试..."); console.log('区分大小写 1'); var 结果 = "Abc123".equal("Abc123"); console.assert(结果 === true); console.log('区分大小写 2');结果 = "aBC123".equal("Abc123");控制台.断言（结果 === 假）； console.log('忽略大小写');结果 = "AbC123".equal("aBc123", true); console.assert(结果 === true); console.log('忽略大小写 + 当前语言环境');结果 = "AbC123".equal("aBc123", true); console.assert(结果 === true); console.log('Turkish test 1 (ignore case, en-US)');结果 = "IiiiI".equal("ıiİI", true, "en-US");控制台.断言（结果 === 假）； console.log('土耳其语测试 2 (忽略大小写，tr-TR)');结果 = "IiiiI".equal("ıiİI", true, "tr-TR"); console.assert(结果 === true); console.log('土耳其语测试 3 (区分大小写，tr-TR)');结果 = "IiiiI".equal("ıiİI", false, "tr-TR");控制台.断言（结果 === 假）； console.log('null-test-1');结果 = "AAA".equal(null);控制台.断言（结果 === 假）； console.log('null-test-2');结果 = String.equal(null, "BBB");控制台.断言（结果 === 假）； console.log('null-test-3');结果 = String.equal(null, null);控制台.断言（结果 === 假）；

---

我们也可以使用 ASCII 来做到这一点：

function toLower(a){

    let c = "";

    
    for(let i = 0;i<a.length;i++){

        
        let f = a.charCodeAt(i);
        if(f < 95){

            c += String.fromCharCode(f+32);
        }
        else{

            c += a[i];
        }
    }

    return c;
}
function compareIt(a,b){


    return toLower(a)==toLower(b);


}
console.log(compareIt("An ExamPlE" , "an example"));

---