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

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

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

toUpperCase

：

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

---

编辑：这个答案最初是9年前添加的。现在，您应该使用

敏感度：'accent'

选项：

函数ciEquals（a，b）{
返回类型a=='string'&&typeof b=='string'
？a.localeCompare（b，未定义，{sensitivity:'accent'}）==0
：a==b；
}
log（“'a'='a'？”，ciEquals（'a'，'a'）；
log（“'AaA'='AaA'？”，ciEquals（'AaA'，'AaA'）；
log（“'a'='á'？”，ciEquals（'a'，'á'）；
log（“'a'='b'？”，ciEquals（'a'，'b'）我写了一个扩展。琐碎

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

在正则表达式的帮助下，我们也可以实现

(/keyword/i).test(source)

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

(/keyword/).test(source)

请记住，套管是特定于区域设置的操作。根据具体情况，您可能需要考虑到这一点。例如，如果您正在比较两个人的名字，您可能需要考虑区域设置，但是如果您正在比较诸如UUID之类的机器生成值，那么您可能不会。这就是我在utils库中使用以下函数的原因（请注意，出于性能原因，不包括类型检查）

如果您关心不平等的方向（也许您想对列表进行排序）
您几乎必须进行大小写转换，而且由于unicode中的小写字符比大写字符多，所以使用小写可能是最好的转换

function my_strcasecmp( a, b ) 
{
    if((a+'').toLowerCase() > (b+'').toLowerCase()) return 1  
    if((a+'').toLowerCase() < (b+'').toLowerCase()) return -1
    return 0
}

函数my\u strcasecmp（a，b）
{
if（（a+“”）.toLowerCase（）>（b+“”）.toLowerCase（）返回1
if（（a+“”）.toLowerCase（）<（b+“”）.toLowerCase（））返回-1
返回0
}

Javascript似乎使用区域设置“C”进行字符串比较，因此结果排序将
如果字符串中包含ASCII字母以外的其他字母，则会很难看。如果不对字符串进行更详细的检查，就没有什么可以做的了。
有两种不区分大小写的比较方法：

将字符串转换为大写，然后使用strict运算符（
==
）进行比较。严格运算符处理操作数读取内容的方式：

使用字符串方法进行模式匹配：
使用“search”字符串方法进行不区分大小写的搜索。
阅读有关搜索和其他字符串方法的信息，请访问：


//第一路
var a=“苹果”；
var b=“苹果”；
如果（a.toUpperCase（）==b.toUpperCase（））{
警惕（“相等”）；
}
//第二条路
var a=“无效”；
document.write（a.search（/null/i））；
甚至这个问题都已经回答了。我有一种不同的方法使用RegExp和match忽略区分大小写。请看我的链接

我最近创建了一个微库，提供不区分大小写的字符串帮助程序：。（它在内部使用
toUpperCase
）

假设我们想在字符串变量haystack

中找到字符串变量needle。有三个陷阱：

国际化应用程序应避免使用

string.toUpperCase

和

string.toLowerCase

。使用忽略大小写的正则表达式。例如，

var neederegexp=newregexp（针，“i”）后接
neederegexp.test（haystack）

通常，您可能不知道

针的值。请注意
needle
不包含任何正则表达式。使用
needle.replace（/[-[\]{}（）*+？，\\^$\\\\s]/g，“\\$&”）

在其他情况下，如果要精确匹配

指针

和

干草堆

，只需忽略大小写，请确保在正则表达式构造函数的开头添加

“^”

，在末尾添加

“$”

考虑到第（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
}

---

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

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

上面的代码段假设您不想匹配任何一个字符串是否为null或未定义

如果要匹配空/未定义，则：

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

如果出于某种原因，您关心未定义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());

---

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

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

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

输出将是：

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

String.prototype.equalIgnoreCase=函数（str）{
返回（str！=null）&&
str的类型==='string'&&
this.toUpperCase（）==str.toUpperCase（））；
}
var a=“你好”；
var b=“你好”；
var c=“世界”；
如果（a.e.酶（b））{
文件。写入（“a==b”）；
文件。写（“
”）；
}
如果（a.c））{
文件。写入（“a==c”）；
}
如果（！b.equalIgnoreCase（c））{
文件。写入（“b！=c”）；
}

由于没有答案明确提供了使用

RegExp

的简单代码片段，因此我尝试如下：

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

它有几个优点：

验证参数类型（例如，任何非字符串参数，如

未定义

，都会使表达式崩溃，如

str1.toUpperCase（）

）

不存在可能的国际化问题

转义

RegExp

字符串

---

使用正则表达式进行字符串匹配或比较

在JavaScript中，可以使用

match（）

进行字符串比较， 别忘了把

i

放在正则表达式中

例如：

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

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

---

如果两个字符串具有相同的已知区域设置，则可能需要使用如下对象：

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

显然，您可能需要缓存

Collator

，以提高效率

这种方法的优点是，它应该比使用regexp快得多，并且基于一个非常可定制的（请参见中的

locales

和

options

构造函数参数的描述）

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

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

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

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

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

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

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

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

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

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