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




d'une caractere (25)

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

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?


Étant donné qu'il y a une plainte à propos de l'utilisation du prototype et de l'utilisation de indexOf votre code est moins lisible, et puisque l'expression rationnelle est excessive:

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

C'est le compromis pour lequel j'ai fini par aller.


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



Vous devez appeler indexOf avec un "O" majuscule 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 null. Vous pouvez faire ce qui suit pour obtenir votre valeur de classe ...

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

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

Détermine si une chaîne peut être trouvée dans une autre chaîne, en renvoyant true ou false selon le cas.

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 à laquelle commencer la recherche de searchString est searchString défaut sur 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  

Remarque

Cela peut nécessiter l'installation de ES6 dans les navigateurs plus anciens.


Dans ES5

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

Dans ES6, il existe 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


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

indexof()

devrait effectivement être

indexOf()

Essayez de le réparer et voyez si cela aide:

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

Dans ES6 , nous avons quelque chose d'appels inclus qui fait exactement ce que vous voulez: vous pouvez simplement faire comme ceci:

'str1'.includes('str2');

Également dans ES5 , si vous l'utilisez beaucoup, vous pouvez simplement l'ajouter comme ceci:

String.prototype.includes = String.prototype.includes || function(str) {
  return this.indexOf(str) > -1;
}

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

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

Exemple

var a  = "Test String";

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

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


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

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

La principale différence entre les deux indexOf fait indexOf concerne uniquement les sous-chaînes, alors que la search prend également en charge les expressions régulières. Bien sûr, utiliser indexOf être plus rapide.

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

Implémentation de votre propre méthode String.prototype.contains()

Si vous voulez ajouter votre propre méthode à chaque chaîne, le meilleur moyen de le faire serait l' de :

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

Vous l'utiliseriez comme ceci:

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

Implémentation d'une bibliothèque d'utilitaires personnalisée

Il est généralement mal vu d'ajouter vos propres méthodes personnalisées aux objets standard en JavaScript, par exemple, car cela risquerait de compromettre la compatibilité.

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

var helper = {};

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

Vous l'utiliseriez comme ceci:

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

Utilisation d'une bibliothèque d'utilitaires tiers

Si vous ne souhaitez pas créer votre propre bibliothèque d'assistance personnalisée, vous avez toujours la possibilité d'utiliser une bibliothèque d'utilitaires tiers. Comme mentionné par , les plus populaires sont Lodash et Underscore.js .

Dans Lodash, vous pouvez utiliser _.includes() , comme ceci:

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

Dans Underscore.js, vous pouvez utiliser _.str.include() , que vous utilisez comme ceci:

_.str.include('Hello World', 'orl');


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

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


Vous pouvez utiliser le sélecteur :contains jQuery.

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

Vérifiez-le ici: contains-selector


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

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


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

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 .


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 donné, la méthode contains détermine si l'élément spécifié est présent ou non dans le tableau. Si l'élément spécifié est présent dans le tableau, il renvoie true, sinon il renvoie false.


Il y a donc beaucoup de solutions utiles à la question - mais laquelle est la plus rapide / utilise le moins de ressources?

Tests répétés utilisant ce cadre:

/usr/bin/time bash -c 'a=two;b=onetwothree; x=100000; while [ $x -gt 0 ]; do TEST ; x=$(($x-1)); done'

Remplacer TEST à chaque fois:

[[ $b =~ $a ]]           2.92user 0.06system 0:02.99elapsed 99%CPU

[ "${b/$a//}" = "$b" ]   3.16user 0.07system 0:03.25elapsed 99%CPU

[[ $b == *$a* ]]         1.85user 0.04system 0:01.90elapsed 99%CPU

case $b in *$a):;;esac   1.80user 0.02system 0:01.83elapsed 99%CPU

doContain $a $b          4.27user 0.11system 0:04.41elapsed 99%CPU

(doContain était dans la réponse de F. Houri)

Et pour les fous rires:

echo $b|grep -q $a       12.68user 30.86system 3:42.40elapsed 19%CPU !ouch!

Ainsi, l'option de substitution simple gagne, que ce soit dans un test étendu ou un cas. L'affaire est portable.

Piping à 100000 greps est prévisible douloureux! L'ancienne règle sur l'utilisation des utilitaires externes sans nécessité est vraie.







javascript string substring contains string-matching