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




vérifier si une chaine contient un caractère java (20)

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

https://code.i-harness.com

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.


Ce morceau de code devrait bien fonctionner:

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

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

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

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


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



Exemple

var a  = "Test String";

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

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

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


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


Voici une liste des possibilités actuelles:

1. (ES6) includes - allez à 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. Si non trouvé, il retournera -1 .

3. search - aller à la réponse

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

4. lodash comprend - allez répondre

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

5. RegExp - allez à 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 tests de performance montrent indexOf pourrait être le meilleur choix si le moment est indexOf pour la rapidité.


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

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

Vous pouvez utiliser le sélecteur :contains jQuery.

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

Vérifiez-le ici: contains-selector


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.


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.





string-matching