Comment vérifier si une chaîne de caractères contient un substrat en JavaScript?

Habituellement, je m'attendrais à une méthode String.contains() , mais il ne semble pas y en avoir une.

Quelle est une façon raisonnable de vérifier cela?

7435
demandé sur Peter O. 2009-11-24 16:04:29
la source

30 ответов

Voici une liste des possibilités actuelles:

1. (ES6) includes - aller à la réponse

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

2. ES5 et plus 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. S'il n'est pas trouvé, il retournera -1 .

3. search - aller à la réponse

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

4. lodash comprend - aller à la réponse

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

5. RegExp - aller à la réponse

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

6. Match - aller à la réponse

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

les essais de Performance montrent que indexOf pourrait être le meilleur choix, s'il s'agit d'un point où la vitesse est importante.

11731
répondu Fabien Ménager 2018-03-28 15:31:10
la source

vous pouvez facilement ajouter une méthode contains à la chaîne avec cette déclaration:

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

Note: voir les commentaires ci-dessous pour un argument valide pour ne pas utiliser ceci. Mon conseil: utilisez votre propre jugement.

alternativement:

if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; }
840
répondu Avi Flax 2016-07-28 04:32:52
la source

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

indexof()

devrait être

indexOf()

essayez de le fixer et voir si cela aide:

if (test.indexOf("title") !=-1) {
    alert(elm);
    foundLinks++;
}
441
répondu Victor 2012-10-18 23:24:03
la source

il y a un string.includes dans ES6 :

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

Note vous pourriez avoir besoin de charger es6-shim ou similaire pour obtenir ce travail sur les navigateurs plus anciens.

require('es6-shim')
383
répondu eliocs 2018-04-13 18:57:05
la source
var index = haystack.indexOf(needle);
347
répondu pixeline 2009-11-24 16:06:27
la source

vous pouvez utiliser la méthode JavaScript search() .

syntaxe: string.search(regexp)

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

voir exemples il: jsref_search

vous n'avez pas besoin d'une syntaxe d'expression régulière compliquée. Si vous ne les connaissez pas, un simple st.search("title") suffira. Si vous voulez que votre test soit insensible à la casse, alors tu devrais faire st.search(/title/i) .

241
répondu Tardis 2011-05-22 22:25:39
la source

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

détermine si une chaîne peut être trouvée dans une autre chaîne, retourner vrai ou faux selon le cas.

syntaxe

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

paramètres

searchString

Une chaîne de caractères à rechercher dans cette chaîne.

position

la position dans cette chaîne à par défaut, pour commencer la recherche de searchString à 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  

Note

cela peut nécessiter un shim ES6 dans les navigateurs plus anciens.

171
répondu Aniket Kulkarni 2016-08-25 09:40:47
la source

si vous cherchiez une alternative pour écrire le laid -1 check, vous préparez un ~ tilde à la place.

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

Joe Zimmerman - vous verrez que l'utilisation de ~ on -1 le convertit à 0. Le nombre 0 est un valeur de falsey, ce qui signifie qu'il va évaluer à false lorsqu'il est converti en booléen. Cela ne ressemble peut-être pas à un grand aperçu au début, mais se souvenir des fonctions comme indexOf retournera -1 quand la requête n'est pas trouver. 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 donc vous pouvez l'écrire comme ceci:

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

plus détails ici

124
répondu ᴉʞuǝ 2016-01-21 09:12:11
la source

ce code devrait bien fonctionner:

var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
} 
86
répondu vaibhav 2012-05-30 11:31:32
la source

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

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

l'opérateur de négation bitwise ( ~ ) est utilisé pour transformer -1 en 0 (falsey), et toutes les autres valeurs seront non-zéro (truthy).

les opérateurs de négation booléenne double sont utilisés pour lancer le nombre dans un booléen.

81
répondu zzzzBov 2017-12-26 16:38:59
la source

In ES5

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

dans ES6 il y a trois nouvelles méthodes: includes() , startsWith() , endsWith() .

var msg = "Hello world!";

console.log(msg.startsWith("Hello"));       // true
console.log(msg.endsWith("!"));             // true
console.log(msg.includes("o"));             // true

console.log(msg.startsWith("o", 4));        // true
console.log(msg.endsWith("o", 8));          // true
console.log(msg.includes("o", 8));          // false
80
répondu Nisar 2016-08-17 02:27:36
la source

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 recommande:


1ère option: utiliser Lodash : il a une includes méthode:

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

Lodash est la plus populaire dépendance de bibliothèque javascript pour npm et a des charges de JavaScript pratique les méthodes de l'utilitaire. Donc, pour beaucoup de projets que vous voulez de toute façon ;-)


2e option: ou utilisez soulignement.chaîne : elle a une include méthode:

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

Voici la description de Underscore.string, il ajoute juste 9kb mais vous donne tous les avantages d'une bibliothèque bien testée et documentée a sur les snippets de code de copy'n'paste:

trait de Soulignement.string est une bibliothèque JavaScript pour une manipulation confortable avec strings, extension pour Underscore.js inspiré par Prototype.js, Droit.js, un trait de Soulignement et beau langage Ruby.

trait de Soulignement.chaîne vous offre plusieurs fonctions utiles: capitaliser, propre, comprend, comte, escapeHTML, unescapeHTML, d'insertion, d'épissure, commencez, terminez, titrez, taillez, tronçonnez et ainsi de suite.

Note Bien, soulignement.string est influencé par Underscore.js , mais peut être utilisé sans elle.


dernier point important: avec la version JavaScript ES6 vient un intégré includes méthode:

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

la plupart des navigateurs modernes le prennent déjà en charge, ont un oeil sur le tableau de compatibilité ES6 .

69
répondu nachtigall 2016-03-04 01:09:28
la source

vous pouvez utiliser le sélecteur :contains de jQuery.

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

Vérifier ici: contient-sélecteur

67
répondu Chorinator 2016-01-04 07:38:49
la source

utiliser une expression régulière:

RegExp.test(string)

63
répondu rahul 2014-07-21 22:38:48
la source

une autre option de faire ceci est:

vous pouvez utiliser la fonction match, c'est-à-dire quelque chose comme:

x = "teststring";

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

match () peut aussi fonctionner avec une expression régulière:

x = "teststring";

if (x.match(/test/i)) {
     // Code
}
56
répondu David Craig 2018-01-26 11:50:20
la source

vous cherchiez .indexOf MDN .

indexOf va retourner un indice au substrat apparié. L'indice sera corrélé à l'endroit où le substrat commence. S'il n'y a pas de correspondance, un -1 est retourné. Voici un simple démo 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)
}
52
répondu Travis J 2016-04-27 14:43:43
la source

vous devez appeler indexOf avec un" O " majuscule comme mentionné. Il convient également de noter que dans JavaScript class est un mot réservé, vous devez utiliser className pour obtenir cet attribut de données. La raison pour laquelle il échoue probablement est 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
51
répondu MillsJROSS 2009-11-24 18:52:20
la source

ça a marché pour moi. Il sélectionne pour les chaînes qui ne contiennent pas le terme "supprimé: "

if (eventString.indexOf("Deleted:") == -1)
51
répondu writtinfool 2011-11-20 05:35:31
la source

comme la question est assez populaire, j'ai pensé que je pourrais ajouter un peu de saveur moderne au code.

// const           : creates an immutable constant
const allLinks   = document.getElementsByTagName("a");
// [].reduce.call  : gives access to the reduce method on a HTMLCollection
// () => {}        : ES6 arrow function
const foundLinks = [].reduce.call(allLinks, (sum, link) => {
     // bitwise OR : converts the boolean value to a number
     return sum + (link.classList.contains("title") | 0);
}, 0);

// template literal
console.log(`Found ${foundLinks || "no"} title class`);

BTW, la bonne réponse est indexOf ou le non-standard String.contains . Charger une bibliothèque externe (surtout si le code est écrit en JavaScript pur) ou jouer avec String.prototype ou utiliser une expression régulière est un peu exagéré.

36
répondu Jay Harris 2017-11-19 17:32:05
la source

il y a une façon élégante et meilleure de le faire et elle utilise l'opérateur (BitWise pas).

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

le Bitwise ne convertit pas" x " en -(x + 1) donc, si le x résulte -1 de la méthode indexOf.elle sera alors convertie en -( -1 + 1) = -0, ce qui est une valeur falsy .

28
répondu Kiba 2014-12-07 14:05:58
la source

String.prototype.indexOf() ou String.prototype.search() ?!

comme d'autres l'ont déjà mentionné, les chaînes JavaScript ont à la fois une méthode indexOf et search .

la principale différence entre les deux, est que indexOf est pour les substrats simples seulement, tandis que search supporte aussi les expressions régulières. Bien sûr, l'avantage d'utiliser indexOf est qu'il est plus rapide.

Voir aussi en JavaScript, Quelle est la différence entre indexOf() et search()? .

la mise en Œuvre de votre propre String.prototype.contains() méthode

si vous voulez ajouter votre propre méthode contains à chaque chaîne, la meilleure façon de le faire serait @zzzzBov l 'approche:

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

vous l'utilisez comme ceci:

'Hello World'.contains('orl');

implémentation d'une bibliothèque utilitaire personnalisée

il est généralement mal vu d'ajouter vos propres méthodes personnalisées à des objets standards en JavaScript, par exemple, parce qu'il pourrait casser la compatibilité forward.

si vous voulez vraiment votre propre méthode contains et / ou d'autres méthodes de chaîne personnalisées, il est préférable de créer votre propre bibliothèque utilitaire et d'ajouter vos méthodes de chaîne personnalisées à cette bibliothèque:

var helper = {};

helper.string = {
    contains : function (haystack, needle) {
        return !!~haystack.indexOf(needle);
    },
    ...
};

You l'utiliserait comme ceci:

helper.string.contains('Hello World', 'orl');

à l'Aide d'un utilitaire tiers bibliothèque

si vous ne voulez pas créer votre propre bibliothèque d'aide personnalisée, il y a - bien sûr - toujours la possibilité d'utiliser une bibliothèque utilitaire tierce. Comme mentionné par @nachtigall , les plus populaires sont Lodash et Underscore.js .

en Lodash, vous pouvez utiliser _.includes() , que vous utilisez comme ceci:

_.includes('Hello World', 'orl');

Dans Le Trait De Soulignement.js, vous pouvez utiliser _.str.include() , que vous utilisez comme ceci:

_.str.include('Hello World', 'orl');
27
répondu John Slegers 2017-05-23 13:31:37
la source

exemple

var a  = "Test String";

if(a.search("ring")!=-1){
     //exist 
} else {
     //not found 
}
25
répondu Ali Abbas 2016-05-31 09:06:34
la source

solution de contournement Simple

if (!String.prototype.contains) {
  String.prototype.contains= function() {
    return String.prototype.indexOf.apply(this, arguments) !== -1;
  };
}

vous pouvez utiliser de la manière suivante

"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains(" ")//true
"hello world".contains("  ")//false

référence MDN

24
répondu Sriramajeyam Sugumaran 2015-08-21 12:45:55
la source

code JavaScript pour utiliser la méthode contains dans un tableau:

<html>
    <head>
        <h2>Use of contains() method</h2>
        <script>
            Array.prototype.contains = function (element) {
                for (var i = 0; i < this.length; i++) {
                    if (this[i] == element) {
                        return true;
                    }
                }
                return false;
            }
            arr1 = ["Rose", "India", "Technologies"];
            document.write("The condition is "+arr1.contains("India")+"<br>");
        </script>
    </head>

    <b>[If the specified element is present in the array, it returns true otherwise
    returns false.]</b>

</html>

Dans le code, le contains méthode détermine si l'élément spécifié est présent dans le tableau ou non. Si l'élément spécifié est présent dans le tableau, il renvoie true, sinon il renvoie false.

21
répondu Tarun Gupta 2014-10-26 13:21:27
la source

pour recueillir une sorte de solutions valables:

var stringVariable = "some text";
var findString = "text";

//using `indexOf()`
var containResult1 = stringVariable.indexOf(findString) != -1;
document.write(containResult1+', ');

//using `lastIndexOf()`
var containResult2 = stringVariable.lastIndexOf(findString) != -1;
document.write(containResult2+', ');

//using `search()`
var containResult3 = stringVariable.search(findString) != -1;
document.write(containResult3+', ');
     
//using `split()`
var containResult4 = stringVariable.split(findString)[0] != stringVariable;
document.write(containResult4+'');
20
répondu shA.t 2017-09-18 07:43:38
la source

Puisqu'il y a une plainte à propos de l'utilisation du prototype, et depuis l'utilisation de indexOf rend votre code moins lisible, et depuis regexp est exagéré:

function stringContains(inputString, stringToFind) {
    return (inputString.indexOf(stringToFind) != -1);
}

C'est le compromis que j'ai fini par accepter.

18
répondu Tjaart 2014-03-25 16:22:31
la source

JavaScript

 var str = "My big string contain apples and oranges";
 var n = str.indexOf("apples"); 
 alert(n); //will alert 22, -1 if not found

jQuery

  <p>My big string contain apples and oranges</p>
  alert($("p:contains(apples)")[0] != undefined); //will alert true if found
17
répondu Alain Gauthier 2014-12-16 21:44:26
la source

utilisez le plus simple I. e match() sur la corde. Pour réaliser ce que vous attendez, faites ceci:

var stringData ="anyString Data";

var subStringToSearch = "any";

// This will give back the substring if matches and if not returns null
var doesContains = stringData.match(subStringToSearch);

if(doesContains !=null) {
    alert("Contains Substring");
}
13
répondu Ankur Madaan 2014-05-03 00:26:01
la source

La easyest moyen est en effet à l'aide de indexOf . De simplement vérifier une chaîne string pour une sous-chaîne substr vous pouvez utiliser cette méthode:

string = "asdf";
substr = "as";
alert(string.indexOf(substr) == -1 ? false : true);

comme vous vouliez la fonction string.contains() , vous pouvez l'implémenter vous-même comme ceci:

String.prototype.contains = function(test) {
    return this.indexOf(test) == -1 ? false : true;
};

Maintenant vous pouvez utiliser cette méthode ecen shorter pour vérifier si une chaîne contient une chaîne spéciale:

string = "asdf";
alert(string.contains("as"));

voici aussi un JSFiddle .

13
répondu frieder 2014-10-26 13:30:27
la source