string supprimer caractère - Comment vérifier si une chaîne contient une sous-chaîne en JavaScript?



15 Answers

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

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

Remarque: voir 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; }; }
d'une chaine jquery

En général, je m'attendrais à une méthode String.contains() , mais il ne semble pas en avoir.

Quel est un moyen raisonnable de vérifier cela?




Il y a un string.includes dans ES6 :

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

Notez que vous devrez peut-être charger es6-shim ou similaire pour que cela fonctionne avec les anciens navigateurs.

require('es6-shim')



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

La syntaxe est la suivante: string.search(regexp)

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

Voir des exemples ici: 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") fera l'affaire. Si vous souhaitez que votre test ne soit pas sensible à la casse, vous devez alors effectuer st.search(/title/i) .




Si vous cherchez une alternative pour écrire le chèque -1, vous préfixez un ~ tilde.

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

Joe Zimmerman - vous constaterez que l'utilisation de ~ on -1 le convertit en 0. Le nombre 0 est une valeur de falsey, ce qui signifie qu'il sera évalué à false s'il est converti en booléen. Cela pourrait ne pas sembler être une grande perspicacité au début, mais souvenez-vous que des fonctions comme indexOf renverront -1 lorsque la requête n’est pas trouvée. Cela signifie qu'au lieu d'écrire quelque chose de similaire à 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




Une méthode courante pour écrire une méthode contains en JavaScript est la suivante:

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

L'opérateur de négation au niveau du bit ( ~ ) est utilisé pour transformer -1 en 0 (Falsey), et toutes les autres valeurs seront non nulles (vérité).

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




Au lieu d'utiliser des extraits de code trouvés ici ou 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: Utiliser Lodash : Il a une méthode includes :

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

Lodash est la dépendance la plus populaire de la bibliothèque javascript pour npm et possède de nombreuses méthodes pratiques d’utilitaire javascript. Donc, pour de nombreux projets, vous voudriez quand même ;-)

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

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

Voici la description de Underscore.string, elle ajoute simplement 9 Ko mais vous offre tous les avantages d'une bibliothèque bien testée et documentée par rapport aux 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, Underscore et du magnifique langage Ruby.

Underscore.string fournit plusieurs fonctions utiles: mettre en majuscule, nettoyer, inclure, compter, escapeHTML, unescapeHTML, insérer, épisser, commence par, commence par, titre, coupe, tronque, etc.

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

Last not Least: avec la version JavaScript de l'ES6, une méthode intégrée includes :

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

La plupart des navigateurs modernes le prennent déjà en charge, consultez le tableau de compatibilité ES6 .







Vous cherchiez .indexOf String.prototype.indexOf .

indexOf va retourner un index à la sous-chaîne correspondante. L'index sera corrélé à l'endroit où la sous-chaîne commence. S'il n'y a pas de correspondance, un -1 est renvoyé. Voici une simple démonstration 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 juste fonctionné pour moi. Il sélectionne les chaînes ne contenant pas le terme "Supprimé:"

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



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

Bitwise Not convertit "x" en - (x + 1). Ainsi, si le x s'avère -1 à partir de la méthode indexOf, il sera converti en - (-1 + 1) = -0, qui est une valeur de fausseté.




Exemple

var a  = "Test String";

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






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




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 la méthode la plus simple et la plus intégrée, à savoir match() sur la chaîne. Pour atteindre vos objectifs, procédez comme suit:

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



Related