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




15 Answers

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

caractere existe

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?




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



var index = haystack.indexOf(needle);



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.




Ce morceau de code devrait bien fonctionner:

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



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




Vous pouvez utiliser le sélecteur :contains jQuery.

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

Vérifiez-le ici: contains-selector




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
}



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



Puisque la question est très populaire, j'ai pensé pouvoir ajouter un peu de modernité 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`);

En passant, la bonne réponse est mal orthographié indexOf ou le indexOf non standard. Charger une bibliothèque externe (surtout si le code est écrit en JavaScript pur), String.prototype avec String.prototype ou utiliser une expression régulière est un peu exagéré.




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



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




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.




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




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



Related