web-dev-qa-db-fra.com

Recherche insensible à la casse

J'essaie d'obtenir une recherche insensible à la casse avec deux chaînes fonctionnant en JavaScript.

Normalement ce serait comme ça:

var string="Stackoverflow is the BEST";
var result= string.search(/best/i);
alert(result);

Le drapeau /i serait insensible à la casse.

Mais je dois chercher une deuxième chaîne; sans le drapeau cela fonctionne parfaitement:

var string="Stackoverflow is the BEST";
var searchstring="best";
var result= string.search(searchstring);
alert(result);

Si j'ajoute l'indicateur /i à l'exemple ci-dessus, il recherchera searchstring et non ce qui se trouve dans la variable "searchstring" (le prochain exemple ne fonctionne pas):

var string="Stackoverflow is the BEST";
var searchstring="best";
var result= string.search(/searchstring/i);
alert(result);

Comment puis-je atteindre cet objectif?

javascriptsearchstring-comparisoncase-insensitive
257
Chris Boesing

Oui, utilisez .match plutôt que .search. Le résultat de l'appel .match renverra la chaîne réelle qui a été mise en correspondance, mais elle peut toujours être utilisée comme valeur booléenne.

var string = "Stackoverflow is the BEST";
var result = string.match(/best/i);
// result == 'BEST';

if (result){
    alert('Matched');
}

Utiliser une expression régulière comme celle-ci est probablement le moyen le plus simple et le plus évident de le faire en JavaScript, mais gardez à l'esprit que est une expression régulière, et peut donc contenir des métacaractères regex. Si vous voulez prendre la chaîne ailleurs (par exemple, entrée utilisateur) ou si vous voulez éviter de devoir échapper à beaucoup de métacaractères, alors vous feriez probablement mieux d'utiliser indexOf comme ceci:

matchString = 'best';
// If the match string is coming from user input you could do
// matchString = userInput.toLowerCase() here.

if (string.toLowerCase().indexOf(matchString) != -1){
    alert('Matched');
}
356
Dan

Remplacer

var result= string.search(/searchstring/i);

avec

var result= string.search(new RegExp(searchstring, "i"));
157
Sergey Ilinsky

Si vous recherchez simplement une chaîne plutôt qu'une expression régulière plus compliquée, vous pouvez utiliser indexOf() - mais souvenez-vous de mettre les deux chaînes en minuscule, car indexOf() est sensible à la casse:

var string="Stackoverflow is the BEST"; 
var searchstring="best";

// lowercase both strings
var lcString=string.toLowerCase();
var lcSearchString=searchstring.toLowerCase();

var result = lcString.indexOf(lcSearchString)>=0;
alert(result);

Ou en une seule ligne:

var result = string.toLowerCase().indexOf(searchstring.toLowerCase())>=0;
37
Odilon Redo

Supposons que nous voulions trouver la variable chaîne needle dans la variable chaîne haystack. Il y a trois pièges:

  1. Les applications internationalisées doivent éviter string.toUpperCase et string.toLowerCase. Utilisez une expression régulière qui ignore la casse. Par exemple, var needleRegExp = new RegExp(needle, "i"); suivi de needleRegExp.test(haystack).
  2. En général, vous pourriez ne pas connaître la valeur de needle. Veillez à ce que needle ne contienne aucune expression régulière caractères spéciaux . Échappez-vous avec needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");.
  3. Dans d'autres cas, si vous souhaitez associer avec précision needle et haystack, en ignorant simplement la casse, veillez à ajouter "^" au début et "$" à la fin du constructeur de votre expression régulière.

En prenant en considération les 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);
alert(result);
18
Chris Chute

ES6 +:

let string="Stackoverflow is the BEST";
let searchstring="best";


let found = string.toLowerCase()
                  .includes(searchstring.toLowerCase());

includes() renvoie true si searchString apparaît à un ou plusieurs emplacements ou false sinon.

3
Andrey

J'aime la réponse de @ CHR15TO, contrairement à d'autres réponses que j'ai vues sur d'autres questions similaires, cette réponse montre en fait comment échapper correctement à une chaîne de recherche fournie par l'utilisateur (plutôt que de dire que cela serait nécessaire sans montrer comment.).

Cependant, il est encore assez maladroit et peut-être relativement plus lent. Alors pourquoi ne pas avoir une solution spécifique à ce qui est probablement une exigence commune aux codeurs? (Et pourquoi ne pas l'inclure dans l'ES6 API BTW?)

Ma réponse [ https://stackoverflow.com/a/38290557/887092] sur une question similaire permet les éléments suivants:

var haystack = 'A. BAIL. Of. Hay.';
var needle = 'bail.';
var index = haystack.naturalIndexOf(needle);
2
Todd

Si vous êtes préoccupé par la casse "classe de caractères non terminée", il serait utile de supprimer tous les caractères non alphanumériques:

searchstring = searchstring.replace (/ [^ a-zA-Z 0-9] +/g, '');
2
dsomnus

Je fais ceci souvent et utilise un prototype simple de 5 lignes qui accepte les varargs. C'est rapide et fonctionne partout .

myString.containsIgnoreCase('red','orange','yellow')


/**
 * @param {...string} var_strings Strings to search for
 * @return {boolean} true if ANY of the arguments is contained in the string
 */
String.prototype.containsIgnoreCase = function(var_strings) {
  const thisLowerCase = this.toLowerCase()
  for (let i = 0; i < arguments.length; i++) {
    let needle = arguments[i]
    if (thisLowerCase.indexOf(needle.toLowerCase()) >= 0) {
      return true
    }
  }
  return false
}

/**
 * @param {...string} var_strings Strings to search for
 * @return {boolean} true if ALL of the arguments are contained in the string
 */
String.prototype.containsAllIgnoreCase = function(var_strings) {
  const thisLowerCase = this.toLowerCase()
  for (let i = 0; i < arguments.length; i++) {
    let needle = arguments[i]
    if (thisLowerCase.indexOf(needle.toLowerCase()) === -1) {
      return false
    }
  }
  return true
}

// Unit test

let content = `
FIRST SECOND
"At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat."
"At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat."
"At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat."
"At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat."
"At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat."
"At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est laborum et dolorum fuga. Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut perferendis doloribus asperiores repellat."
FOO BAR
`

let data = [
  'foo',
  'Foo',
  'foobar',
  'barfoo',
  'first',
  'second'
]

let result
data.forEach(item => {
  console.log('Searching for', item)
  result = content.containsIgnoreCase(item)
  console.log(result ? 'Found' : 'Not Found')
})

console.log('Searching for', 'x, y, foo')
result = content.containsIgnoreCase('x', 'y', 'foo');
console.log(result ? 'Found' : 'Not Found')

console.log('Searching for all', 'foo, bar, foobar')
result = content.containsAllIgnoreCase('foo', 'bar', 'foobar');
console.log(result ? 'Found' : 'Not Found')

console.log('Searching for all', 'foo, bar')
result = content.containsAllIgnoreCase('foo', 'bar');
console.log(result ? 'Found' : 'Not Found')

1
Steven Spungin

Il y a deux manières de faire une comparaison insensible à la casse:

  1. Convertissez les chaînes en majuscules, puis comparez-les à l'aide de l'opérateur strict (===). Comment un opérateur strict traite les opérandes en lisant les choses à: http://www.thesstech.com/javascript/relational-logical-operators

  2. Pattern matching en utilisant des méthodes de chaîne:

    Utilisez la méthode de chaîne "search" pour la recherche ne respectant pas la casse . Pour en savoir plus sur la recherche et les autres méthodes de chaîne, rendez-vous à l'adresse suivante: 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>
1
Sohail Arif

Vous pouvez tout faire en minuscule:

var string="Stackoverflow is the BEST";
var searchstring="best";
var result= (string.toLowerCase()).search((searchstring.toLowerCase()));
alert(result);
0
Robbert