javascript - Hoe kan ik hoofdletterongevoelige tekenreeksen vergelijken?

Hoe kan ik hoofdletterongevoelige tekenreeksen vergelijken in JavaScript?

Antwoord 1, autoriteit 100%

De eenvoudigste manier om dit te doen (als u zich geen zorgen maakt over speciale Unicode-tekens) is door toUpperCasete bellen:

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

Antwoord 2, autoriteit 21%

EDIT: dit antwoord is oorspronkelijk 9 jaar geleden toegevoegd. Vandaag zou je localeComparemet de sensitivity: 'accent'optie:

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

Antwoord 3, autoriteit 7%

Zoals gezegd in recente opmerkingen, string::localeCompareondersteunt hoofdletterongevoelige vergelijkingen (onder andere krachtige dingen).

Hier is een eenvoudig voorbeeld

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

En een algemene functie die je zou kunnen gebruiken

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

Houd er rekening mee dat u in plaats van undefinedwaarschijnlijk de specifieke landinstelling moet invoeren waarmee u werkt. Dit is belangrijk zoals aangegeven in de MDN-documenten

in het Zweeds zijn ä en a aparte basisletters

Gevoeligheidsopties

Browserondersteuning

Op het moment van posten ondersteunt UC Browser voor Android en Opera Mini geenparameters voor localeen opties. Controleer https://caniuse.com/#search=localeComparevoor actuele informatie.

Antwoord 4, autoriteit 3%

Met behulp van reguliere expressie kunnen we dit ook bereiken.

(/keyword/i).test(source)

/iis voor negeer. Indien niet nodig, kunnen we negeren en testen op NIET hoofdlettergevoelige overeenkomsten zoals

(/keyword/).test(source)

Antwoord 5, autoriteit 2%

Vergeet niet dat de behuizing een locale-specifieke werking is. Afhankelijk van scenario wil je dat misschien in rekening brengen. Als u bijvoorbeeld namen vergelijkt met twee personen, wilt u misschien in overweging nemen van Locale, maar als u Machine-gegenereerde waarden vergelijkt, zoals UUID, dan is u misschien niet. Hiermee gebruik ik de volgende functie in My Utils Library (opmerking die typecontrole niet is inbegrepen voor prestatiereden).

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

Antwoord 6

Als u zich zorgen maakt over de richting van de ongelijkheid (misschien wilt u een lijst sorteren)
Je hoeft vrijwel te doen case-conversie, en omdat er meer kleine letters in Unicode zijn dan hoofdletters tolowercase is waarschijnlijk de beste conversie om te gebruiken.

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

JavaScript lijkt Locale “C” te gebruiken voor stringvergelijkingen, zodat de resulterende bestel
wees lelijk als de snaren anders dan ASCII-letters bevatten. Er is niet veel die daarover kan worden gedaan zonder veel meer gedetailleerde inspectie van de snaren te doen.

Antwoord 7

Ik heb onlangs een microbibliotheek gemaakt die niet-hoofdlettergevoelige tekenreekshelpers biedt: https://github.com /nickuraltsev/ignore-case. (Het gebruikt intern 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

Antwoord 8

Stel dat we de stringvariabele needlewillen vinden in de stringvariabele haystack. Er zijn drie valkuilen:

Internationale toepassingen moeten string.toUpperCaseen string.toLowerCasevermijden. Gebruik in plaats daarvan een reguliere expressie die hoofdletters negeert. Bijvoorbeeld var needleRegExp = new RegExp(needle, "i");gevolgd door needleRegExp.test(haystack).
Over het algemeen weet u de waarde van needlemisschien niet. Zorg ervoor dat needlegeen reguliere expressie bevat speciale tekens. Ontsnap aan deze met needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");.
In andere gevallen, als u needleen haystackprecies wilt matchen, waarbij u hoofdletters negeert, zorg er dan voor dat u "^"toevoegt aan het begin en "$"aan het einde van uw reguliere expressie-constructor.

Rekening houdend met de punten (1) en (2), zou een voorbeeld zijn:

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
}

Antwoord 9

Veel antwoorden hier, maar ik wil graag een oplossing toevoegen op basis van het uitbreiden van de String-lib:

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

Op deze manier kun je het gewoon gebruiken zoals in Java!

Voorbeeld:

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

Uitvoer zal zijn:

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

Antwoord 10

Gebruik Regex voor String Match of vergelijking.

In JavaScript kunt u match()voor stringvergelijking gebruiken,
Vergeet niet om iin Regex te plaatsen.

Voorbeeld:

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

Antwoord 11

Er zijn twee manieren voor case ongevoelige vergelijking:

Converteer strings naar hoofdletters en vergelijk ze dan met behulp van de strikte operator (===). Hoe strenge operator operanden spullen lezen bij:
http://www.thesstech.com/javascript/relational-logical-operators
patroon matching met stringmethoden:

Gebruik de stringmethode “Zoeken” voor case ongevoelig zoeken.
Lees meer over zoeken en andere stringmethoden op:
http://www.thesstech.com/pattern-matching-using-string-methoden

<!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>

Antwoord 12

Zelfs deze vraag is al beantwoord. Ik heb een andere benadering om Regexp te gebruiken en overeenkomt met het negeren van hoofdlettergevoelig. Zie mijn link
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);
  }

Antwoord 13

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

Antwoord 14

Als beide strings van dezelfde bekende landinstelling zijn, wilt u misschien Intl.Collatorobject als volgt:

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

Het is duidelijk dat je de Collatorwilt cachen voor een betere efficiëntie.

De voordelen van deze aanpak is dat het veel sneller zou moeten zijn dan het gebruik van RegExps en gebaseerd is op een uiterst aanpasbare (zie beschrijving van localesen optionsconstructorparameters in de artikel hierboven) set kant-en-klare verzamelprogramma’s.

Antwoord 15

Ik heb een extensie geschreven. heel triviaal

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

Antwoord 16

Ik vind deze snelle shorthare variatie leuk –

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

Snel in verwerking en doet wat het is bedoeld.

Antwoord 17

Hoe zit het met het niet gooien van uitzonderingen en het niet gebruiken van Slow Regex?

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

Het bovenstaande fragment veronderstelt dat u niet wilt matchen als een string null of undefined is.

Als u null / undefined wilt matchen, dan:

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

Als om een of andere reden om 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());

Antwoord 18

Aangezien geen antwoord duidelijk een eenvoudig codefragment heeft verstrekt voor het gebruik van RegExp, hier is mijn poging:

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

Het heeft verschillende voordelen:

Verifieert het parametertype (elke niet-stringparameter, zoals undefinedbijvoorbeeld, zou een expressie als str1.toUpperCase()laten crashen).
Heeft geen last van mogelijke internationaliseringsproblemen.
Ontsnapt aan de RegExp-tekenreeks.

Antwoord 19

Als je weet dat je te maken hebt met ascii-tekst, kun je een vergelijking tussen hoofdletters en kleine letters gebruiken.

Zorg er wel voor dat de tekenreeks van uw “perfecte” tekenreeks (degene waarmee u wilt matchen) kleine letters is:

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

Antwoord 20

Voor een betere browsercompatibiliteit kunt u vertrouwen op een reguliere expressie. Dit werkt in alle webbrowsers die de afgelopen 20 jaar zijn uitgebracht:

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

Dit is anders dan de andere antwoorden die hier worden gevonden omdat het rekening houdt met het feit dat niet alle gebruikers moderne webbrowsers gebruiken.

Opmerking: als u ongebruikelijke gevallen als de Turkse taal moet ondersteunen, moet u LoceCompare gebruiken omdat ik en ik niet dezelfde letter in het Turks zijn.

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

Antwoord 21

Dit is een verbeterde versie van dit antwoord .

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

Usages & AMP; Tests:

Antwoord 22

Zet beide om in lager (slechts één keer om prestatieredenen) en vergelijk ze met de ternaire operator op één regel:

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

Previous articleTypeError: ‘int’-object ondersteunt geen itemtoewijzing

Next articleHoud het simpel en doe meerdere CTE’s in een query

Hoe kan ik hoofdletterongevoelige tekenreeksen vergelijken?