จะเปรียบเทียบสตริงตัวพิมพ์เล็กและใหญ่ได้อย่างไร?

ฉันจะทำการเปรียบเทียบสตริงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ใน 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'));

การ{ 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 คือการใช้match()เมธอดRegExp กับiแฟล็ก

การค้นหาแบบคำนึงถึงขนาดตัวพิมพ์

เมื่อเปรียบเทียบทั้งสองสตริงเป็นตัวแปร (ไม่ใช่ค่าคงที่) มันก็ซับซ้อนกว่าเล็กน้อย 'คุณต้องสร้าง RegExp จากสตริง แต่การส่งสตริงไปยังตัวสร้าง RegExp อาจทำให้การจับคู่ไม่ถูกต้องหรือการจับคู่ล้มเหลวหากสตริงมี regex พิเศษ ตัวละครในนั้น

หากคุณสนใจเกี่ยวกับความเป็นสากลอย่าใช้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 เป็นตัวอักษรฐานแยกต่างหาก

ตัวเลือกความไว

รองรับเบราว์เซอร์

เมื่อถึงเวลาโพสต์ UC Browser สำหรับ Android และ Opera Mini ไม่รองรับภาษาและตัวเลือกพารามิเตอร์ โปรดตรวจสอบ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;
}

ผมได้สร้างเมื่อเร็ว ๆ นี้มีห้องสมุดขนาดเล็กที่ให้กรณีตายผู้ช่วยเหลือสตริง: 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

หากคุณมีความกังวลเกี่ยวกับทิศทางของความไม่เท่าเทียมกัน (บางทีคุณต้องการเรียงลำดับรายการ) คุณต้องทำการแปลงเป็นกรณี ๆ ไปและเนื่องจากมีอักขระตัวพิมพ์เล็กในยูนิโค้ดมากกว่าตัวพิมพ์ใหญ่ toLowerCase อาจเป็นการแปลงที่ดีที่สุดที่จะใช้

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

ดูเหมือนว่าจาวาสคริปต์จะใช้ภาษา "C" สำหรับการเปรียบเทียบสตริงดังนั้นการเรียงลำดับผลลัพธ์จะน่าเกลียดถ้าสตริงมีอักขระอื่นนอกเหนือจากตัวอักษร ASCII มีไม่มากที่สามารถทำได้โดยไม่ต้องทำการตรวจสอบรายละเอียดเพิ่มเติมของสตริง

สมมติว่าเราต้องการหาตัวแปรสตริง needlehaystackในตัวแปรสตริง มีสาม gotchas:

1. แอปพลิเคชันสากลควรหลีกเลี่ยงstring.toUpperCaseและstring.toLowerCaseและใช้นิพจน์ทั่วไปที่ไม่สนใจตัวพิมพ์ใหญ่ - เล็กแทน ยกตัวอย่างเช่นตามมาด้วยvar needleRegExp = new RegExp(needle, "i");needleRegExp.test(haystack)
2. needleโดยทั่วไปแล้วคุณอาจไม่ทราบว่าค่าของ ระวังที่needleไม่มีนิพจน์ทั่วไปใด ๆอักขระพิเศษ needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");หนีเหล่านี้โดยใช้
3. ในกรณีอื่น ๆ หากคุณต้องการจับคู่อย่างแม่นยำ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
}

มีสองวิธีสำหรับการเปรียบเทียบแบบคำนึงถึงขนาดตัวพิมพ์:

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>

มีคำตอบมากมายที่นี่ แต่ฉันต้องการเพิ่มตัวทำละลายตามการขยาย 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");
}

ใช้ RegEx สำหรับการจับคู่สตริงหรือการเปรียบเทียบ

ใน JavaScript คุณสามารถใช้match()สำหรับการเปรียบเทียบสตริงอย่าลืมใส่iใน RegEx

ตัวอย่าง:

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

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 มากและขึ้นอยู่กับการปรับแต่งอย่างมาก (ดูคำอธิบายlocalesและoptionsพารามิเตอร์คอนสตรัคเตอร์ในบทความด้านบน) ชุด collators พร้อมใช้งาน

ฉันเขียนส่วนขยาย เรื่องไม่สำคัญมาก

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

แม้แต่คำถามนี้ก็ได้ตอบไปแล้ว ฉันมีวิธีอื่นในการใช้ 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);

  }

วิธีการเกี่ยวกับการไม่โยนข้อยกเว้นและไม่ใช้ regex ช้า?

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

ตัวอย่างด้านบนถือว่าคุณไม่ต้องการจับคู่หากสตริงใดข้อความหนึ่งเป็นโมฆะหรือไม่ได้กำหนดไว้

หากคุณต้องการจับคู่เป็นโมฆะ / ไม่ได้กำหนดแล้ว:

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

เนื่องจากไม่มีคำตอบที่ให้ข้อมูลโค้ดง่ายๆสำหรับการใช้งานอย่างชัดเจน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สตริง

นี่เป็นรุ่นปรับปรุงของคำตอบนี้

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;

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

แปลงทั้งคู่ให้ต่ำลง (เพียงครั้งเดียวสำหรับเหตุผลด้านประสิทธิภาพ) และเปรียบเทียบกับผู้ประกอบการที่ประกอบไปด้วยสามบรรทัดในบรรทัดเดียว:

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

หากคุณรู้ว่าคุณกำลังเผชิญกับ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())
}

รวดเร็วในการประมวลผลและทำตามที่ตั้งใจไว้

javascriptดูเหมือนว่าไลบรารีนี้จะให้การดำเนินงานสตริงจำนวนมาก มันสะดวกมากที่จะใช้

ติดตั้งอย่างไร

npm install --save string

นำเข้า

var S = require('string');

Ignorecase เปรียบเทียบสตริง

var isEqual = S('ignoreCase').equalsIgnoreCase('IGNORECASE')