සිද්ධි සංවේදී නොවන නූල් සංසන්දනය කරන්නේ කෙසේද?

ජාවාස්ක්‍රිප්ට් හි සිද්ධි සංවේදී නොවන නූල් සංසන්දනය කරන්නේ කෙසේද?

එය කළ හැකි සරලම ක්‍රමය (ඔබ විශේෂ යුනිකෝඩ් අක්ෂර ගැන කරදර නොවන්නේ නම්) අමතන්න 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සමාන ලෙස සලකනු ලැබේ á).

තෙවන පරාමිතිය localeCompareIE10 හෝ ඊට අඩු හෝ ඇතැම් ජංගම බ්‍රව්සර් සඳහා සහය නොදක්වන බව සලකන්න (ඉහත සම්බන්ධ කර ඇති පිටුවේ අනුකූලතා සටහන බලන්න), එබැවින් ඔබට එම බ්‍රව්සර් සඳහා සහය දැක්වීමට අවශ්‍ය නම්, ඔබට යම් ආකාරයක පසුබෑමක් අවශ්‍ය වේ:

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

මුල් පිළිතුර

ජාවාස්ක්‍රිප්ට් හි සංවේදී නොවන සංසන්දනයක් කිරීමට හොඳම match()ක්‍රමය වන්නේ iධජය සමඟ RegExp ක්‍රමය භාවිතා කිරීමයි .

සිද්ධි සංවේදී නොවන සෙවීම

නූල් දෙකම සංසන්දනය කරන විට විචල්‍යයන් (නියතයන් නොවේ), එය තව ටිකක් සංකීර්ණ 'හේතුවකි, ඔබට නූලෙන් 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ඔබ වෙනුවට ඔබ වැඩ කරන විශේෂිත ස්ථානයට ඇතුළු විය යුතු බව සලකන්න . එම්ඩීඑන් ලේඛනයේ දක්වා ඇති පරිදි මෙය වැදගත් වේ

ස්වීඩන් භාෂාවෙන් ä සහ a වෙනම මූලික අකුරු වේ

සංවේදීතා විකල්ප

බ්‍රව්සර් සහාය

වෙබ් අඩවියේ කාලය වන විට, Android සහ ඔපෙරා මිනි සදහා වවුනියාව නගර බ්රව්සරය නැහැ සහාය පෙදෙසි සහ විකල්ප පරාමිතීන්. යාවත්කාලීන තොරතුරු සඳහා කරුණාකර https://caniuse.com/#search=localeCompare පරීක්ෂා කරන්න.

නිත්‍ය ප්‍රකාශනයේ ආධාරයෙන් අපට ද ළඟා කර ගත හැකිය.

(/keyword/i).test(source)

/iනඩුව නොසලකා හැරීම සඳහා ය. අවශ්‍ය නොවේ නම් අපට නොසලකා හැර පරීක්‍ෂා කළ නොහැක

(/keyword/).test(source)

ආවරණයක් යනු ස්ථානීය විශේෂිත මෙහෙයුමක් බව මතක තබා ගන්න. තත්වය අනුව ඔබට එය සැලකිල්ලට ගත යුතුය. උදාහරණයක් ලෙස, ඔබ පුද්ගලයින් දෙදෙනෙකුගේ නම් සංසන්දනය කරන්නේ නම් ඔබට පෙදෙසි සලකා බැලීමට අවශ්‍ය විය හැකි නමුත් ඔබ යූඅයිඅයිඩී වැනි යන්ත්‍ර ජනනය කළ අගයන් සංසන්දනය කරන්නේ නම් එසේ නොවනු ඇත. මේ නිසා මම මගේ උපයෝගිතා පුස්තකාලයේ පහත සඳහන් ශ්‍රිතය භාවිතා කරමි (කාර්ය සාධන හේතුව සඳහා වර්ග පරීක්ෂා කිරීම ඇතුළත් කර නොමැති බව සලකන්න).

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

අසමානතාවයේ දිශාව ගැන ඔබ සැලකිලිමත් වන්නේ නම් (සමහර විට ඔබට ලැයිස්තුවක් වර්ග කිරීමට අවශ්‍ය වනු ඇත) ඔබට බොහෝ විට සිද්ධි පරිවර්තනය කළ යුතු අතර, යුනිකෝඩ් වල කුඩා අකුරු විශාල අකුරුවලට වඩා අඩු අගයක් ඇති බැවින් බොහෝ විට භාවිතා කිරීමට හොඳම පරිවර්තනය විය හැකිය.

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

ජාවාස්ක්‍රිප්ට් "සී" පෙදෙසි නූල් සැසඳීම් සඳහා භාවිතා කරන බව පෙනේ, එබැවින් ASCII අක්ෂර හැර වෙනත් නූල් අඩංගු වන්නේ නම් එහි අනුපිළිවෙල කැත වේ. නූල් පිළිබඳ වඩාත් සවිස්තරාත්මක පරීක්ෂාවකින් තොරව ඒ පිළිබඳව කළ හැකි බොහෝ දේ නොමැත.

: මම මෑතකදී නඩුව-අසංවේදී string කාරයෙක් සපයන ක්ෂුද්ර පුස්තකාල නිර්මාණය කර ඇත 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

අපට නූල් විචල්‍යය needleතුළ string විචල්‍යය සොයා ගැනීමට අවශ්‍ය යැයි සිතමු haystack. ගොචා තුනක් ඇත:

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
}

මෙහි පිළිතුරු ගොඩක් ඇත, නමුත් නූල් ලිබ් දිගු කිරීම මත පදනම්ව ද්‍රාවණයක් එක් කිරීමට මම කැමතියි:

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");
}
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 භාවිතා කරන්න.

ජාවාස්ක්‍රිප්ට් හි, ඔබට match()නූල් සංසන්දනය සඳහා භාවිතා කළ හැකිය, iරෙජෙක්ස් දැමීමට අමතක නොකරන්න .

උදාහරණයක්:

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

මෙම ප්රශ්නයට පවා දැනටමත් පිළිතුරු දී ඇත. සිද්ධි සංවේදී නොසලකා හැරීම සඳහා 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);

  }

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වඩා හොඳ කාර්යක්ෂමතාව සඳහා හැඹිලිය කිරීමට අවශ්‍ය විය හැකිය .

මෙම ප්‍රවේශයේ ඇති වාසි වන්නේ එය රෙජීඑක්ස් භාවිතා කිරීමට වඩා වේගවත් විය යුතු අතර එය අතිශයින්ම රිසිකරණය කළ හැකි ( ඉහත ලිපියේ විස්තරය localesසහ optionsඉදිකිරීම් පරාමිතීන් බලන්න) භාවිතා කිරීමට සූදානම් කොලෙටර් කට්ටලයක් මත ය.

මම දිගුවක් ලිව්වා. ඉතා සුළු කාරණයක්

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

ඉහත සඳහන් ස්නිපටය උපකල්පනය කරන්නේ ඔබට නූල් අහෝසි වී හෝ නිර්වචනය කර නොමැති නම් ගැලපීමට අවශ්‍ය නොවන බවයි.

ඔබට ශුන්‍ය / නිර්වචනය නොකළ ගැලපීමට අවශ්‍ය නම්:

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

කිසියම් හේතුවක් නිසා ඔබ නිර්වචනය නොකළ එදිරිව ශුන්‍ය නම්:

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

නොසලකා හරින්න

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