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

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

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

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')

var index = haystack.indexOf(needle);

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) .

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.

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

ce code devrait bien fonctionner:

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

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.

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

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 .

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

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

Vérifier ici: contient-sélecteur

utiliser une expression régulière:

RegExp.test(string)

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
}

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

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

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

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

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é.

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 .

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');

exemple

var a  = "Test String";

if(a.search("ring")!=-1){
     //exist 
} else {
     //not found 
}

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

ES6 contient String.prototype.includes .

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes

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.

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+'');

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.

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

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

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 .