JavaScript chaîne casse comparaison

EDIT : cette réponse a 7 ans. Aujourd'hui, vous devriez utiliser localeCompare .

réponse Originale à cette question

la meilleure façon de faire une comparaison non sensible à la casse en JavaScript est D'utiliser la méthode RegExp match() avec le drapeau 'i'.

JavaScript: non à la casse de la recherche

quand les deux cordes sont comparées sont des variables (pas des constantes), alors c'est un peu plus compliqué parce que vous avez besoin de générer un RegExp à partir de la chaîne de caractères, mais passer la chaîne de caractères au constructeur RegExp peut entraîner des correspondances incorrectes ou des correspondances manquées si la chaîne de caractères contient des caractères regex Spéciaux.

si vous vous souciez de l'internationalisation, n'utilisez pas toLowerCase() ou toUpperCase() car cela ne fournit pas de comparaisons précises dans toutes les langues.

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

rappelez-vous que le tubage est une opération locale spécifique. Selon le scénario vous pouvez prendre cela en compte. Par exemple, si vous comparez les noms de deux personnes, vous pourriez vouloir considérer locale mais si vous comparez les valeurs générées par la machine telles que UUID alors vous pourriez ne pas. C'est pourquoi j'utilise la fonction suivante dans ma bibliothèque utils (notez que la vérification de type n'est pas incluse pour des raisons de performance).

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

avec l'aide de l'expression régulière aussi nous pouvons atteindre.

(/keyword/i).test(source)

/i est pour ignorer le cas. Si ce n'est pas nécessaire, nous pouvons ignorer et tester une correspondance non sensible à la casse comme

(/keyword/).test(source)

si vous êtes préoccupé par la direction de l'inégalité (peut-être vous voulez trier une liste) vous avez à peu près tout à faire cas-conversion, et comme il ya plus de caractères minuscules dans unicode que majuscule toLowerCase est probablement la meilleure conversion à utiliser.

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

Javascript semble utiliser la locale "C" pour les comparaisons de chaîne de sorte que l'ordre résultant sera être laid si les chaînes contiennent autre que des lettres ASCII. il n'y a pas beaucoup qui peut être fait à propos de cela sans faire beaucoup plus d'inspection détaillée des chaînes.

j'ai récemment créé une micro-bibliothèque qui fournit des helpers à chaîne non sensibles à la casse: https://github.com/nickuraltsev/ignore-case . (Il utilise toUpperCase à l'interne.)

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

supposons que nous voulions trouver la variable string needle dans la variable string haystack . Il y a trois gotchas:

1. les applications internationalisées doivent éviter string.toUpperCase et string.toLowerCase . Utilisez une expression régulière qui ignore case à la place. Par exemple, var needleRegExp = new RegExp(needle, "i"); suivi de needleRegExp.test(haystack) .
2. En général, vous ne connaissez pas la valeur de needle . Attention: needle ne contient pas toute expression régulière caractères spéciaux . Échapper à ces utiliser needle.replace(/[-[\]{}()*+?.,\^$|#\s]/g, "\$&"); .
3. dans d'autres cas, si vous voulez exactement faire correspondre needle et haystack , en ignorant simplement le cas, assurez-vous d'ajouter "^" au début et "$" à la fin de votre constructeur d'expression régulière.

compte tenu des points 1) et 2), un exemple serait:

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
}

comme dit dans les commentaires récents, string::localCompare soutient des comparaisons insensibles à la casse (entre autres choses puissantes).

voici un exemple simple

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

et une fonction générique que vous pourriez utiliser

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

notez qu'au lieu de undefined vous devez probablement entrer la localisation spécifique avec laquelle vous travaillez. Ceci est important comme indiqué dans les documents du MDN

en Suédois, ä et a sont des lettres de base séparées

les options de Sensibilité

prise en charge du Navigateur

au moment de la publication, UC Browser pour Android et Opera Mini ne pas support locale et options paramètres". Veuillez cocher la case https://caniuse.com/#search=localeCompare pour des informations à jour.

il y a deux façons de comparer les cas insensibles:

1. Convertissez les chaînes en majuscules et comparez-les en utilisant l'opérateur strict ( === ). Comment l'opérateur traite les opérandes: http://www.thesstech.com/javascript/relational-logical-operators
2. la correspondance de Motif à l'aide de méthodes string:

utilisez la méthode de chaîne de caractères" search " pour case recherche insensible. Lisez à propos de la recherche et d'autres méthodes string à: 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>

beaucoup de réponses ici, mais j'aime ajouter une solution basée sur l'extension de la chaîne lib:

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

de Cette façon, vous pouvez simplement l'utiliser comme vous le faites en Java!

exemple:

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

sortie sera:

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

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

même cette question a déjà répondu. J'ai une approche différente pour utiliser RegExp et match pour ignorer les cas sensibles. Veuillez voir mon lien 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);

  }

utiliser regix pour match ou comparaison de chaîne,

dans javaScript , vous pouvez utiliser match () pour la comparaison de chaîne de caractères , n'oubliez pas de mettre i dans regix

exemple:

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

Que Diriez-vous de ne pas lancer d'exceptions et de ne pas utiliser de regex lent?

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

l'extrait ci-dessus suppose que vous ne voulez pas faire correspondre si l'une des chaînes est nulle ou non définie.

si vous voulez faire correspondre null / undefined, puis:

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

si pour une raison quelconque vous vous souciez de non défini 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());

comme aucune réponse ne fournit clairement un simple extrait de code pour utiliser RegExp , voici ma tentative:

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

il a plusieurs avantages:

1. vérifie le type de paramètre (tout paramètre non-string, comme undefined par exemple, écraserait une expression comme str1.toUpperCase() ).
2. ne souffre pas de problèmes possibles d'internationalisation.
3. échappe à la RegExp chaîne.

si les deux cordes sont du même lieu connu, vous pouvez utiliser Intl.Collator objet comme ceci:

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

évidemment, vous pouvez mettre en cache le Collator pour une meilleure efficacité.

les avantages de cette approche est qu'elle devrait être beaucoup plus rapide que L'utilisation de RegExps et est basée sur un extrêmement personnalisable (voir la description de locales et options paramètres du constructeur dans l'article ci-dessus) jeu de collateurs prêts à l'emploi.

j'ai écrit une extension. très trivial

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