Contient la casse


414

J'ai ce qui suit:

if (referrer.indexOf("Ral") == -1) { ... }

Ce que je veux faire est de rendre Ralinsensible à la casse, de sorte qu'il puisse être RAl, rAletc. et toujours correspondre.

Y a-t-il un moyen de dire que cela Raldoit être insensible à la casse?


3
Je pense que l'expression rationnelle insensible à la casse est la solution la plus élégante, mais tout le monde devrait garder à l'esprit les pièges de la création RegExpdirecte d'une entrée utilisateur. Par exemple, un utilisateur pourrait entrer *et une erreur serait lancée dans le RegExpconstructeur. La solution acceptée n'a pas ce problème.
suppliez le

Réponses:


605

Ajouter .toLowerCase()après referrer. Cette méthode transforme la chaîne en une chaîne minuscule. Ensuite, utilisez .indexOf()à la ralplace de Ral.

if (referrer.toLowerCase().indexOf("ral") === -1) { 

La même chose peut également être obtenue en utilisant une expression régulière (particulièrement utile lorsque vous souhaitez tester des modèles dynamiques):

if (!/Ral/i.test(referrer)) {
   //    ^i = Ignore case flag for RegExp

16
Cette dernière méthode est plus correcte; le premier échouera pour le turc I et toutes les autres paires majuscules / minuscules problématiques: i18nguy.com/unicode/turkish-i18n.html
Domenic

23
Pour le turc, il serait préférable d'utiliser toLocaleLowerCase()( ref )
Mottie

2
ce dernier ne répond pas à la question, il dit seulement s'il est là, ne récupère pas l'index de la correspondance. Soit le titre de la question est faux, soit la question.
Maslow

10
@Maslow L'exemple de la question portait sur le test de l'insensibilité à la casse. Si vous voulez obtenir l'index, utilisez la méthode de la chaîne.search :var index = referrer.search(/Ral/i);
Rob W

7
La complication supplémentaire de l'approche dynamique des expressions régulières est que si la chaîne de recherche, par exemple "Ral", contenait des caractères spéciaux d'expression régulière, tels que $. *? etc., vous auriez des problèmes, vous auriez donc besoin d'échapper aux caractères spéciaux, voir la réponse de Mike Samuel sur ce post: endsWith in JavaScript
zachelrath

94

Une autre option consiste à utiliser la méthode de recherche comme suit:

if (referrer.search(new RegExp("Ral", "i")) == -1) { ...

Il semble plus élégant que de convertir la chaîne entière en minuscules et il peut être plus efficace.
Avec toLowerCase()le code, deux passes sur la chaîne, une passe sur toute la chaîne pour la convertir en minuscules et une autre pour rechercher l'index souhaité.
Avec RegExple code, passez une passe sur la chaîne qui semble correspondre à l'index souhaité.

Par conséquent, sur les chaînes longues, je recommande d'utiliser la RegExpversion (je suppose que sur les chaînes courtes, cette efficacité vient du fait de la création de l' RegExpobjet)


2
C'est aussi un peu plus rapide d'après mes tests: jsperf.com/case-insensitive-indexof
Ilan Biala

6
À partir du 2018.10.24, toLowerCase gagne par une large marge dans Chrome. toLowerCase (95,914,378 - ± 0,89% - le plus rapide), index regexOf (269,307 - ± 0,87% 100% plus lent)
nixkuroi

21

Utilisez un RegExp:

if (!/ral/i.test(referrer)) {
    ...
}

Ou utilisez .toLowerCase():

if (referrer.toLowerCase().indexOf("ral") == -1)

1
+1, cela pourrait potentiellement être plus correct en évitant le «problème turc I» et d'autres pièges de ce type: i18nguy.com/unicode/turkish-i18n.html
Domenic

15

Depuis ES2016, vous pouvez également utiliser une méthode légèrement meilleure / plus facile / plus élégante (sensible à la casse):

if (referrer.includes("Ral")) { ... }

ou (insensible à la casse):

if (referrer.toLowerCase().includes(someString.toLowerCase())) { ... }

Voici une comparaison de .indexOf()et .includes(): https://dev.to/adroitcoder/includes-vs-indexof-in-javascript


1
Je ne pense pas que les inclusions soient insensibles à la casse
Kyle s

4
@Kyles includesest sensible à la casse dans Chrome: essayez 'fooBar'.includes('bar')==>false
drzaus

10

Il y a quelques approches ici.

Si vous souhaitez effectuer une vérification insensible à la casse pour cette instance uniquement, procédez comme suit.

if (referrer.toLowerCase().indexOf("Ral".toLowerCase()) == -1) {
    ...

Alternativement, si vous effectuez cette vérification régulièrement, vous pouvez ajouter une nouvelle indexOf()méthode similaire à String, mais la rendre insensible à la casse.

String.prototype.indexOfInsensitive = function (s, b) {
    return this.toLowerCase().indexOf(s.toLowerCase(), b);
}

// Then invoke it
if (referrer.indexOfInsensitive("Ral") == -1) { ...

1
Pour les navigateurs modernes qui prennent en charge defineProperty, je suggère Object.defineProperty(String.prototype, 'indexOfInsensitive', {value: function(s,b){return this.toLowerCase().indexOf((s+'').toLowerCase(),b);}});. Deux mises à jour: conversion de chaîne explicite utilisant (s+'')et non énumérable dans une boucle ( for(var i in '') ... ne s'affiche pas indexOfInsensitive.
Rob W

5
if (referrer.toUpperCase().indexOf("RAL") == -1) { ...

@Domenic: Avec tout le respect dû à la culture turque, la Turquie devrait envisager une réforme orthographique pour simplifier cet aspect. La Chine a eu un certain nombre de réformes de simplification , et la Turquie a moins de 10% de la population chinoise et un alphabet beaucoup plus simple. Ça peut être fait.
Dan Dascalescu

5

Vous pouvez essayer ceci

str = "Wow its so COOL"
searchStr = "CoOl"

console.log(str.toLowerCase().includes(searchStr.toLowerCase()))


3

Exemple pour n'importe quelle langue:

'My name is Хведор'.toLocaleLowerCase().includes('ХвЕдОр'.toLocaleLowerCase())

2

Nous sommes en 2016, et il n'y a pas de moyen clair de procéder? J'espérais un peu de copypasta. Je vais essayer.

Notes de conception: je voulais minimiser l'utilisation de la mémoire, et donc améliorer la vitesse - il n'y a donc pas de copie / mutation des chaînes. Je suppose que le V8 (et d'autres moteurs) peut optimiser cette fonction.

//TODO: Performance testing
String.prototype.naturalIndexOf = function(needle) {
    //TODO: guard conditions here

    var haystack = this; //You can replace `haystack` for `this` below but I wan't to make the algorithm more readable for the answer
    var needleIndex = 0;
    var foundAt = 0;
    for (var haystackIndex = 0; haystackIndex < haystack.length; haystackIndex++) {
        var needleCode = needle.charCodeAt(needleIndex);
        if (needleCode >= 65 && needleCode <= 90) needleCode += 32; //ToLower. I could have made this a function, but hopefully inline is faster and terser
        var haystackCode = haystack.charCodeAt(haystackIndex);
        if (haystackCode >= 65 && haystackCode <= 90) haystackCode += 32; //ToLower. I could have made this a function, but hopefully inline is faster and terser

        //TODO: code to detect unicode characters and fallback to toLowerCase - when > 128?
        //if (needleCode > 128 || haystackCode > 128) return haystack.toLocaleLowerCase().indexOf(needle.toLocaleLowerCase();
        if (haystackCode !== needleCode)
        {
            foundAt = haystackIndex;
            needleIndex = 0; //Start again
        }
        else
            needleIndex++;

        if (needleIndex == needle.length)
            return foundAt;
    }

    return -1;
}

Ma raison pour le nom:

  • Doit avoir IndexOf dans le nom
  • N'ajoutez pas de suffixe - Of fait référence au paramètre suivant
  • N'utilisez pas "caseInsensitive" qui est trop long
  • «naturel» est un bon candidat, car les comparaisons sensibles à la casse par défaut ne sont pas naturelles aux humains en premier lieu.

Pourquoi pas...:

  • toLowerCase() - appels répétés potentiels à toLowerCase sur la même chaîne.
  • RegExp- maladroit pour rechercher avec variable. Même l'objet RegExp est maladroit d'avoir à échapper des caractères

2
Nous sommes en 2016, et vous pensez toujours que l'anglais (ou d'autres langues ASCII uniquement) est la seule langue au monde?
Roland Illig

3
@RolandIllig Ouch. Ma réponse ne tient pas compte des autres cultures, c'est un inconvénient. Je serais ravi de tout aperçu de l'élargissement du soutien à plus de cultures, le monde est un meilleur endroit avec des collaborateurs.
Todd

1

Pour effectuer une meilleure recherche, utilisez le code suivant,

var myFav   = "javascript";
var theList = "VB.NET, C#, PHP, Python, JavaScript, and Ruby";

// Check for matches with the plain vanilla indexOf() method:
alert( theList.indexOf( myFav ) );

// Now check for matches in lower-cased strings:
alert( theList.toLowerCase().indexOf( myFav.toLowerCase() ) );

Dans la première alerte (), JavaScript a renvoyé "-1" - en d'autres termes, indexOf () n'a pas trouvé de correspondance: c'est simplement parce que "JavaScript" est en minuscules dans la première chaîne et correctement capitalisé dans la seconde. Pour effectuer des recherches non sensibles à la casse avec indexOf (), vous pouvez rendre les deux chaînes en majuscules ou en minuscules. Cela signifie que, comme dans la deuxième alerte (), JavaScript ne vérifiera que l'occurrence de la chaîne que vous recherchez, la capitalisation ignorée.

Référence, http://freewebdesigntutorials.com/javaScriptTutorials/jsStringObject/indexOfMethod.htm


1

Si referrerest un tableau, vous pouvez utiliserfindIndex()

 if(referrer.findIndex(item => 'ral' === item.toLowerCase()) == -1) {...}

0

Voici mon point de vue:

Script :

var originalText = $("#textContainer").html()
$("#search").on('keyup', function () {
  $("#textContainer").html(originalText)
  var text = $("#textContainer").html()
  var val = $("#search").val()
  if(val=="") return;
  var matches = text.split(val)
  for(var i=0;i<matches.length-1;i++) {
    var ind =  matches[i].indexOf(val)
    var len = val.length
      matches[i] = matches[i] + "<span class='selected'>" + val + "</span>"
  }
  $("#textContainer").html(matches.join(""))

HTML:

<input type="text" id="search">
<div id="textContainer">
lorem ipsum is simply dummy text of the printing and typesetting industry. lorem ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of letraset sheets containing lorem ipsum passages, and more recently with desktop publishing software like Aldus pagemaker including versions of lorem ipsum.</div>

Codepen

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.