不区分大小写的字符串比较怎么办?

2020/09/18 15:31 · javascript ·  · 0评论

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

最简单的方法(如果您不担心特殊的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, { sensitivity: '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'));

The { sensitivity: 'accent' }Tells 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中进行不区分大小写的比较的最好方法是使用match()带有i标志的RegExp 方法

不区分大小写的搜索

当两个被比较的字符串都是变量(不是常量)时,这会稍微复杂一点,因为您需要从字符串生成RegExp,但是如果字符串具有特殊的regex,则将字符串传递给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是单独的基本字母

灵敏度选项

从MDN列出的灵敏度选项

浏览器支持

在发布时,适用于Android和Opera Mini的UC浏览器支持区域设置选项参数。请检查https://caniuse.com/#search=localeCompare以获取最新信息。

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

(/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-casetoUpperCase内部使用。)

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

假设我们要在string变量needle找到string变量haystack有三个陷阱:

  1. 国际化的应用程序应避免string.toUpperCasestring.toLowerCase请使用忽略大小写的正则表达式。例如,var needleRegExp = new RegExp(needle, "i");接着是needleRegExp.test(haystack)
  2. 通常,您可能不知道的值needle注意needle不要包含任何正则表达式特殊字符使用逃脱这些needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
  3. 在其他情况下,如果要精确匹配needlehaystack,而忽略大小写,请确保"^""$"正则表达式构造函数的开头和结尾处添加

考虑到第(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 lib的解决方案:

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

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

  1. 将字符串转换为大写,然后使用严格运算符(===比较它们严格的运算符对待操作数的方式在以下位置读取内容:http :
    //www.thesstech.com/javascript/relational-logical-operators
  2. 使用字符串方法进行模式匹配:

使用“搜索”字符串方法进行不区分大小写的搜索。在以下网址了解有关搜索和其他字符串方法的信息: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>

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

在JavaScript中,您可以使用它match()来进行字符串比较,不要忘记将其放在iRegEx中。

例:

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

甚至这个问题都已经回答了。我有另一种使用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);

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

如果两个字符串都具有相同的已知语言环境,则可能要使用如下Intl.Collator对象:

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

显然,您可能需要缓存以Collator获得更好的效率。

这种方法的优点是,它应该比使用RegExps快得多,并且基于一组非常可定制的(请参见上文的说明localesoptions构造函数参数)一组即用型整理器。

我写了一个扩展名。非常琐碎

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

如何不抛出异常并且不使用慢速正则表达式呢?

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

如果出于某种原因您关心未定义vs空:

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

它具有几个优点:

  1. 验证参数类型(undefined例如,任何非字符串参数都将使像这样的表达式崩溃str1.toUpperCase())。
  2. 不会遭受可能的国际化问题。
  3. 转义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;
}

我喜欢这种速记速记变体-

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

快速处理,并按预期进行。

为了获得更好的浏览器兼容性,您可以依靠正则表达式。这将适用于过去20年中发布的所有网络浏览器:

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

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

注意:如果您需要支持土耳其语等特殊情况,则需要使用localeCompare,因为我和我在土耳其语中的字母不同。

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

这是一个改进版这个答案

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);
}
本文地址:http://javascript.askforanswer.com/buqufendaxiaoxiedezifuchuanbijiaozenmeban.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!