Wie überprüft man, ob eine Zeichenkette eine Teilkette in JavaScript enthält?


Answers

Sie können eine contains Methode mit dieser Anweisung zu String hinzufügen:

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

Hinweis: In den folgenden Kommentaren finden Sie ein gültiges Argument dafür, dies nicht zu verwenden. Mein Rat: Verwenden Sie Ihr eigenes Urteil.

Alternative:

if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; }
Question

Normalerweise würde ich eine String.contains() -Methode erwarten, aber es scheint keine zu geben.

Was ist ein vernünftiger Weg dies zu überprüfen?




Eine andere Möglichkeit dies zu tun ist:

Sie können die Match-Funktion verwenden, also etwa:

x = "teststring";

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

match () kann auch mit regulärem Ausdruck arbeiten:

x = "teststring";

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



Einfache Problemumgehung

if (!String.prototype.contains) {
  String.prototype.contains= function() {
    return String.prototype.indexOf.apply(this, arguments) !== -1;
  };
}

Sie können auf folgende Weise verwenden

"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains(" ")//true
"hello world".contains("  ")//false

MDN-Referenz




Sie können jQuery's verwenden :contains Selektor.

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

Überprüfen Sie es hier: contains-selector







Sie suchten nach .indexOf String.prototype.indexOf .

indexOf wird einen Index an die übereinstimmende Teilzeichenfolge zurückgeben. Der Index korreliert mit dem Beginn der Teilzeichenfolge. Wenn es keine Übereinstimmung gibt, wird eine -1 zurückgegeben. Hier ist eine einfache Demo dieses Konzepts:

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




JavaScript-Code zur Verwendung der contains Methode in einem Array:

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

In dem angegebenen Code bestimmt die Methode contains , ob das angegebene Element im Array vorhanden ist oder nicht. Wenn das angegebene Element im Array vorhanden ist, wird true zurückgegeben, andernfalls wird false zurückgegeben.




Wenn Sie nach einer Alternative suchen, um den hässlichen -1-Haken zu schreiben, fügen Sie stattdessen eine ~ Tilde hinzu.

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

Joe Zimmerman - Sie werden sehen, dass die Verwendung von ~ bei -1 ihn in 0 umwandelt. Die Zahl 0 ist ein falscher Wert, was bedeutet, dass sie bei der Umwandlung in einen Booleschen Wert zu false ausgewertet wird. Das mag zunächst keine große Erkenntnis sein, aber erinnern Sie sich, dass Funktionen wie indexOf -1 zurückliefern, wenn die Abfrage nicht gefunden wird. Dies bedeutet, dass, anstatt etwas ähnliches zu schreiben:

if (someStr.indexOf("a") >= 0) {
  // Found it
} else  {
  // Not Found
}

Sie können jetzt weniger Zeichen in Ihrem Code haben, damit Sie es so schreiben können:

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

Mehr Details hier




var index = haystack.indexOf(needle);



Sie könnten die JavaScript search() -Methode verwenden.

Syntax ist: string.search(regexp)

Es gibt die Position der Übereinstimmung oder -1 zurück, wenn keine Übereinstimmung gefunden wird.

Siehe Beispiele dort: jsref_search

Sie benötigen keine komplizierte Syntax für reguläre Ausdrücke. Wenn Sie nicht mit ihnen vertraut sind, wird eine einfache st.search("title") . Wenn Sie möchten, dass Ihr Test nicht zwischen Groß- und Kleinschreibung unterscheidet, sollten Sie st.search(/title/i) .




Es gibt eine schlanke und bessere Möglichkeit, dies zu tun, und es verwendet den Operator (BitWise NOT).

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

Das Bitwise Not wandelt "x" in - (x + 1) um, wenn das x -1 der indexOf-Methode wird. Dann wird es in - (-1 + 1) = -0 umgewandelt, was ein falscher Wert ist.




Um einige gültige Lösungen zu sammeln:

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



Eine übliche Methode zum Schreiben einer contains Methode in JavaScript ist:

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

Der bitweise Negationsoperator ( ~ ) wird verwendet, um -1 in 0 (falsch) zu verwandeln, und alle anderen Werte sind nicht Null (truthy).

Die doppelten booleschen Negationsoperatoren werden verwendet, um die Zahl in einen booleschen Wert zu transformieren.




Der einfachste Weg ist in der Tat mit indexOf . Um nur einen String für einen Substring- substr zu überprüfen, können Sie diese Methode verwenden:

string = "asdf";
substr = "as";
alert(string.indexOf(substr) == -1 ? false : true);

Wie Sie die Funktion string.contains() wollten, können Sie sie folgendermaßen selbst implementieren:

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

Jetzt können Sie mit dieser kürzeren Methode prüfen, ob eine Zeichenfolge eine spezielle Teilzeichenfolge enthält:

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

Hier ist auch ein JSFiddle .






Links