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


Answers

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

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

Note: voir les commentaires ci-dessous pour un argument valable 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; }; }
Question

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

Quel est un moyen raisonnable de vérifier cela?




Une autre option consiste à:

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

x = "teststring";

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

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

x = "teststring";

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



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




Un moyen courant 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 de bits ( ~ ) est utilisé pour transformer -1 en 0 (falsey), et toutes les autres valeurs seront non nulles (vérité).

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




var index = haystack.indexOf(needle);



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 démo 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)
}




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

La syntaxe est: string.search(regexp)

Il renvoie la position du match, 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 n'êtes pas familier avec eux, un simple st.search("title") fera l'affaire. Si vous voulez que votre test soit insensible à la casse, alors vous devriez faire st.search(/title/i) .




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 dans le tableau ou non. Si l'élément spécifié est présent dans le tableau, il renvoie true, sinon il renvoie false.




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




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






Vous pouvez utiliser jQuery's :contains selector.

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

Vérifiez-le ici: contains-selector




Le moyen le plus simple est en effet d'utiliser indexOf . Pour vérifier simplement une chaîne de string pour une sous-chaîne, 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 comme ceci:

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

Vous pouvez maintenant utiliser cette méthode ecen plus courte pour vérifier si une chaîne contient une sous-chaîne spéciale:

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

Voici également un JSFiddle .




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

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

Le bitwise Non convertit "x" en - (x + 1) donc, si le x est -1 de la méthode indexOf, il sera converti en - (-1 + 1) = -0 qui est une valeur falsifiée.




Si vous cherchez une alternative pour écrire la vérification -1 moche, vous préférez 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 une valeur falsey, ce qui signifie qu'il sera évalué à false lorsqu'il est converti en un booléen. Cela peut ne pas sembler une grande idée au début, mais rappelez-vous des fonctions comme indexOf renverront -1 quand 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 pour pouvoir l'écrire comme ceci:

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

Plus de détails ici




Links