Bagaimana cara melakukan perbandingan string case insensitive?

Bagaimana cara saya melakukan perbandingan string yang tidak sensitif huruf pada JavaScript?

Cara termudah untuk melakukannya (jika Anda tidak khawatir tentang karakter Unicode khusus) adalah menelepon toUpperCase:

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

EDIT : Jawaban ini awalnya ditambahkan 9 tahun yang lalu. Hari ini Anda harus menggunakan localeComparedengan sensitivity: 'accent'opsi:

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' }memberitahu localeCompare()untuk mengobati dua varian surat dasar yang sama sebagai yang sama kecuali mereka memiliki aksen yang berbeda (seperti dalam contoh ketiga) di atas.

Atau, Anda dapat menggunakan { sensitivity: 'base' }, yang memperlakukan dua karakter sebagai setara selama karakter dasarnya adalah sama (sehingga Aakan diperlakukan sebagai setara dengan á).

Perhatikan bahwa parameter ketiga localeComparetidak didukung di IE10 atau lebih rendah atau peramban seluler tertentu (lihat bagan kompatibilitas pada halaman yang ditautkan di atas), jadi jika Anda perlu mendukung peramban tersebut, Anda akan memerlukan semacam fallback:

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  */;
}

Jawaban asli

Cara terbaik untuk melakukan perbandingan kasus yang tidak sensitif dalam JavaScript adalah menggunakan match()metode RegExp dengan ibenderanya.

Pencarian case-sensitive

Ketika kedua string yang dibandingkan adalah variabel (bukan konstanta), maka itu sedikit lebih rumit karena Anda perlu membuat RegExp dari string tetapi meneruskan string ke konstruktor RegExp dapat menghasilkan kecocokan yang salah atau kecocokan yang gagal jika string memiliki regex khusus karakter di dalamnya.

Jika Anda peduli tentang internasionalisasi, jangan gunakan toLowerCase()atau toUpperCase()karena tidak memberikan perbandingan kasus-sensitif yang akurat dalam semua bahasa.

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

Seperti yang dikatakan dalam komentar baru-baru ini, string::localeComparemendukung perbandingan kasus sensitif (antara hal-hal kuat lainnya).

Ini contoh sederhana

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

Dan fungsi generik yang bisa Anda gunakan

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

Perhatikan bahwa alih-alih undefinedAnda mungkin harus memasukkan lokal spesifik yang Anda gunakan untuk bekerja. Ini penting sebagaimana dinyatakan dalam dokumen MDN

dalam bahasa Swedia, ä dan a adalah huruf dasar yang terpisah

Opsi sensitivitas

Dukungan browser

Pada saat pengeposan, UC Browser untuk Android dan Opera Mini tidak mendukung parameter lokal dan opsi . Silakan periksa https://caniuse.com/#search=localeCompare untuk info terkini.

Dengan bantuan ekspresi reguler juga bisa kita raih.

(/keyword/i).test(source)

/iuntuk mengabaikan kasus. Jika tidak perlu, kita dapat mengabaikan dan menguji untuk TIDAK pertandingan yang sensitif seperti

(/keyword/).test(source)

Ingatlah bahwa casing adalah operasi khusus lokal. Bergantung pada skenario, Anda mungkin ingin mempertimbangkannya. Misalnya, jika Anda membandingkan nama dua orang, Anda mungkin ingin mempertimbangkan lokal tetapi jika Anda membandingkan nilai yang dihasilkan mesin seperti UUID maka Anda mungkin tidak. Ini sebabnya saya menggunakan fungsi berikut di perpustakaan utils saya (perhatikan bahwa pengecekan tipe tidak termasuk untuk alasan kinerja).

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

Saya baru-baru ini membuat perpustakaan mikro yang menyediakan pembantu string case-insensitive: https://github.com/nickuraltsev/ignore-case . (Ini menggunakan toUpperCaseinternal.)

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

jika Anda khawatir tentang arah ketidaksetaraan (mungkin Anda ingin menyortir daftar), Anda cukup banyak harus melakukan konversi kasus, dan karena ada lebih banyak karakter huruf kecil di unicode daripada huruf besar keLowerCase mungkin konversi terbaik untuk digunakan.

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

Javascript tampaknya menggunakan lokal "C" untuk perbandingan string sehingga urutan yang dihasilkan akan jelek jika string berisi selain huruf ASCII. tidak banyak yang dapat dilakukan tentang itu tanpa melakukan pemeriksaan yang lebih rinci dari string.

Misalkan kita ingin mencari variabel string needledalam variabel string haystack. Ada tiga gotcha:

1. Aplikasi internasional harus menghindari string.toUpperCasedan string.toLowerCase. Gunakan ekspresi reguler yang mengabaikan huruf besar-kecil. Misalnya var needleRegExp = new RegExp(needle, "i");diikuti oleh needleRegExp.test(haystack).
2. Secara umum, Anda mungkin tidak tahu nilai needle. Hati-hati agar needletidak mengandung ekspresi reguler karakter khusus . Lari ini menggunakan needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");.
3. Dalam kasus lain, jika Anda ingin mencocokkan secara tepat needledan haystack, hanya mengabaikan huruf besar, pastikan untuk menambahkan "^"di awal dan "$"di akhir konstruktor ekspresi reguler Anda.

Mempertimbangkan poin (1) dan (2), contohnya adalah:

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
}

Ada dua cara untuk perbandingan kasus sensitif:

1. Konversikan string ke huruf besar dan kemudian bandingkan dengan menggunakan operator ketat ( ===). Cara ketat operator memperlakukan operan membaca hal-hal di: http://www.thesstech.com/javascript/relational-logical-operators
2. Pencocokan pola menggunakan metode string:

Gunakan metode string "pencarian" untuk pencarian case-sensitive. Baca tentang pencarian dan metode string lainnya di: 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>

Banyak jawaban di sini, tapi saya ingin menambahkan solusi berdasarkan memperpanjang lib String:

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

Dengan cara ini Anda bisa menggunakannya seperti yang Anda lakukan di Jawa!

Contoh:

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

Output akan menjadi:

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

Gunakan RegEx untuk pencocokan string atau perbandingan.

Dalam JavaScript, Anda dapat menggunakan match()untuk perbandingan string, jangan lupa untuk memasukkan iRegEx.

Contoh:

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

Jika kedua string memiliki lokal yang sama, Anda mungkin ingin menggunakan Intl.Collatorobjek seperti ini:

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

Jelas, Anda mungkin ingin melakukan cache Collatoruntuk efisiensi yang lebih baik.

Keuntungan dari pendekatan ini adalah bahwa ia harus jauh lebih cepat daripada menggunakan RegExps dan didasarkan pada seperangkat kolektor siap pakai yang digunakan (lihat deskripsi localesdan optionsparameter konstruktor dalam artikel di atas).

Saya menulis ekstensi. sangat sepele

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

Bahkan pertanyaan ini sudah dijawab. Saya memiliki pendekatan berbeda untuk menggunakan RegExp dan mencocokkan untuk mengabaikan case sensitif. Silakan lihat tautan saya 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);

  }

Bagaimana kalau TIDAK melempar pengecualian dan TIDAK menggunakan regex lambat?

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

Cuplikan di atas menganggap Anda tidak ingin mencocokkan jika string tersebut nol atau tidak terdefinisi.

Jika Anda ingin mencocokkan null / tidak terdefinisi, maka:

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

Jika karena alasan tertentu Anda peduli tentang 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());

Karena tidak ada jawaban yang dengan jelas memberikan cuplikan kode sederhana untuk digunakan RegExp, inilah upaya saya:

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

Ini memiliki beberapa keunggulan:

1. Memverifikasi jenis parameter (parameter non-string, seperti undefinedmisalnya, akan menabrak ekspresi sepertistr1.toUpperCase() ).
2. Tidak menderita kemungkinan masalah internasionalisasi.
3. Melepaskan RegExpstring.

Ini adalah versi perbaikan dari jawaban ini .

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

Ubah keduanya menjadi lebih rendah (hanya sekali untuk alasan kinerja) dan bandingkan dengan operator ternary dalam satu baris:

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

Jika Anda tahu Anda berurusan dengan asciiteks maka Anda bisa menggunakan perbandingan offset huruf besar / kecil.

Pastikan string Anda "sempurna" (yang ingin Anda cocokkan) adalah huruf kecil:

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

Saya suka variasi tulisan cepat ini -

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

Cepat dalam pemrosesan, dan melakukan apa yang dimaksudkan.

javascriptPerpustakaan ini tampaknya menyediakan banyak operasi string. Sangat nyaman digunakan

Bagaimana cara meng-install

npm install --save string

Impor

var S = require('string');

Abaikan Bandingkan String

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