Comment vérifier si une chaîne contient une sous-chaîne en JavaScript?

Voici une liste des possibilités actuelles:

1. indexOf

 var string = "foo", substring = "oo"; string.indexOf(substring) !== -1; 

String.prototype.indexOf renvoie la position de la chaîne dans l'autre chaîne. Si elle n'est pas trouvée, elle renverra -1 .

2. (ES6) comprend – aller à la réponse , ou cette réponse

 var string = "foo", substring = "oo"; string.includes(substring); 

3. recherche – allez répondre

 var string = "foo", expr = /oo/; string.search(expr); 

4. lodash inclut – aller répondre

 var string = "foo", substring = "oo"; _.includes(string, substring); 

5. RegExp – aller répondre

 var string = "foo", expr = /oo/; // no quotes here expr.test(string); 

6. Match – aller répondre

 var string = "foo", expr = /oo/; string.match(expr); 

Les tests de performance ( http://jsben.ch/#/RVYk7 ) montrent que indexOf pourrait être le meilleur choix, s'il s'agit d'un point où la vitesse est importante.

Vous pouvez facilement ajouter une méthode contains à String avec cette instruction:

 String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; 

Remarque: consultez les commentaires ci-dessous pour un argument valide pour ne pas l'utiliser. Mon conseil: utilisez votre propre jugement.

Alternativement:

 if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; } 

Le problème avec votre code est que le JavaScript est sensible à la casse. Votre appel de méthode

 indexof() 

Devrait effectivement être

 indexOf() 

Essayez de le réparer et de voir si cela vous aide:

 if (test.indexOf("title") !=-1) { alert(elm); foundLinks++; } 

 var index = haystack.indexOf(needle); 

Mise à jour pour 2015 : string.includes a été ajouté à la prochaine version de JavaScript, ES6 :

 "potato".includes("to"); > true 

Notez que vous devrez charger es6-shim ou similaire pour que cela fonctionne sur les anciens navigateurs.

 require('es6-shim') 

Vous pouvez utiliser la méthode de search() JavaScript search() .

La syntaxe est: string.search(regexp)

Il renvoie la position de la correspondance, ou -1 si aucune correspondance n'est trouvée.

Voir les exemples: jsref_search

Vous n'avez pas besoin d'une syntaxe d'expression régulière compliquée. Si vous ne les connaissez pas, une simple recherche de st.search("title") fera. Si vous voulez que votre test soit insensible à la casse, alors vous devriez effectuer st.search(/title/i) .

String.prototype.includes() été introduit dans ES6.

Détermine si une chaîne peut être trouvée dans une autre chaîne, renvoyant vrai ou faux, le cas échéant.

Syntaxe

 var contained = str.includes(searchString [, position]); 

Paramètres

 searchString 

Une chaîne à rechercher dans cette chaîne.

 position 

La position dans cette chaîne pour commencer à rechercher searchString défaut est 0.

Exemple

 var str = "To be, or not to be, that is the question."; console.log(str.includes("To be")); // true console.log(str.includes("question")); // true console.log(str.includes("To be", 1)); // false 

Si vous étiez à la recherche d'une alternative pour écrire la vérification de la fièvre -1, vous préférez plutôt à ~ tilde.

 if (~haystack.indexOf('needle')) alert('found'); 

Joe Zimmerman – vous verrez que l'utilisation de ~ on -1 le convertit en 0. Le nombre 0 est une valeur de fausse valeur, ce qui signifie qu'il sera évalué à faux lorsqu'il sera converti en booléen. Cela pourrait ne pas sembler une grande perspicacité au début, mais rappelez-vous que les fonctions comme indexOf renverront -1 lorsque la requête n'est pas trouvée. Cela signifie qu'au lieu d'écrire quelque chose de semblable à ceci:

 if (someStr.indexOf("a") >= 0) { // Found it } else { // Not Found } 

Vous pouvez maintenant avoir moins de caractères dans votre code afin que vous puissiez l'écrire comme ceci:

 if (~someStr.indexOf("a")) { // Found it } else { // Not Found } 

Plus de détails ici

Ce code devrait bien fonctionner:

 var str="This is testing for javascript search !!!"; if(str.search("for") != -1) { //logic } 

Dans ES5

 var s = "foo"; alert(s.indexOf("oo") > -1); 

Une façon courante d'écrire une méthode contains JavaScript est:

 if (!String.prototype.contains) { String.prototype.contains = function (arg) { return !!~this.indexOf(arg); }; } 

L'opérateur négation par bit ( ~ ) est utilisé pour transformer -1 en 0 (faux) et toutes les autres valeurs seront non nulles (vérité).

Les opérateurs de négation double booléenne sont utilisés pour convertir le nombre en booléen.

Vous pouvez utiliser jQuery :contains sélecteur.

 $("div:contains('John')") 

Vérifiez ici: contient-sélecteur

Au lieu d'utiliser des extraits de code trouvés ici et là sur le Web, vous pouvez également utiliser une bibliothèque bien testée et documentée. Deux options que je recommanderais:

1ère option: utilisez Lodash : elle a une méthode includes :

 _.includes('foobar', 'ob'); // → true 

Lodash est la dépendance de bibliothèque javascript la plus populaire pour npm et dispose de nombreuses méthodes utilitaires javascript pratiques. Donc, pour de nombreux projets, vous le voudriez de toute façon 😉

2ème option: Ou utilisez Underscore.string : elle comporte une méthode d' include :

 _.str.include('foobar', 'ob'); // → true 

Voici la description de Underscore.string, il ajoute seulement 9kb mais vous offre tous les avantages qu'une bibliothèque bien testée et documentée possède sur des extraits de code copy'n'paste:

Underscore.string est une bibliothèque JavaScript pour une manipulation confortable avec des chaînes, une extension pour Underscore.js inspirée de Prototype.js, Right.js, soulignement et belle langue Ruby.

Underscore.string vous fournit plusieurs fonctions utiles: capitaliser, nettoyer, inclure, compter, échouerHTML, unescapeHTML, insérer, épisser, démarrer avec les extrémités, titrer, décaler, tronquer et ainsi de suite.

Notez bien, Underscore.string est influencé par Underscore.js mais peut être utilisé sans lui.

Dernier pas le moins: avec la version JavaScript ES6 vient une méthode intégrée includes :

 'foobar'.includes('ob'); // → true 

La plupart des navigateurs modernes le supportent déjà, regardez la table de compatibilité ES6 .

Utilisez une expression régulière:

RegExp.test(string)

Vous recherchez .indexOf ^MDN .

indexOf va renvoyer un index à la sous-chaîne appariée. L'indice sera en corrélation avec l'origine de la sous-chaîne. S'il n'y a pas de correspondance, un -1 est retourné. Voici une démonstration simple de ce concept:

 var str = "Hello World"; // For example, lets search this string, var term = "World"; // for the term "World", var index = str.indexOf(term); // and get its index. if (index != -1) { // If the index is not -1 then the term was matched in the string, alert(index); // and we can do some work based on that logic. (6 is alerted) } 

Cela a simplement fonctionné pour moi. Il sélectionne pour les chaînes qui ne contiennent pas le terme "Supprimé:"

 if (eventString.indexOf("Deleted:") == -1) 

Vous devez appeler indexOf avec un "O" principal comme mentionné. Il convient également de noter que dans la classe JavaScript est un mot réservé, vous devez utiliser className pour obtenir cet attribut de données. La raison pour laquelle il échoue est probablement parce qu'il renvoie une valeur nulle. Vous pouvez faire ce qui suit pour obtenir votre valeur de classe …

 var test = elm.getAttribute("className"); //or var test = elm.className 

Une autre option est de:

Vous pouvez utiliser la fonction de correspondance, c'est-à-dire quelque chose comme:

 x = "teststring"; if (x.match("test")) { // Code } 

Comme la question est assez populaire, j'ai pensé pouvoir ajouter un peu de saveur moderne au code.

 var allLinks = content.document.getElementsByTagName("a") , il = allLinks.length , i = 0 , test , alrt; while (i < il) { elm = allLinks[i++]; test = elm.getAttribute("class"); if (test.indexOf("title") > -1) console.log(elm), foundLinks++; } alrt = foundLinks ? "Found " + foundLinks + " title class" : "No title class found"; console.log(alrt); 

BTW, la réponse correcte est indexOf ou le indexOf non standard. Le chargement d'une bibliothèque externe (surtout si le code est écrit en JavaScript pur) ou le String.prototype avec String.prototype ou l'utilisation d'une expression régulière est un petit peu.

Il existe un moyen élégant et meilleur de le faire et il utilise l'opérateur (BitWise NOT).

 if(~"John".indexOf("J")) { alert("Found") } else { alert("Not Found"); } 

The Bitwise Ne convertis pas "x" dans – (x + 1) donc, si le x s'avère -1 à partir de la méthode indexOf. Alors il sera converti en – (-1 + 1) = -0 qui est une valeur faussement.