zerlegen Wie prüfe ich, ob eine Zeichenfolge eine Unterzeichenfolge in JavaScript enthält?




javascript string zerlegen (20)

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

Was ist eine vernünftige Möglichkeit, dies zu überprüfen?

https://code.i-harness.com


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

Wie bereits erwähnt, verfügen JavaScript-Zeichenfolgen über eine String.prototype.indexOf und eine search .

Der Hauptunterschied zwischen beiden besteht darin, dass indexOf nur für einfache indexOf gilt, während die search auch reguläre Ausdrücke unterstützt. Ein indexOf der Verwendung von indexOf ist natürlich, dass es schneller ist.

Siehe auch In JavaScript, was ist der Unterschied zwischen indexOf () und search ()? .

Implementieren Ihrer eigenen String.prototype.contains() -Methode

Wenn Sie zu jeder Zeichenfolge eine eigene Methode enthalten möchten, der Ansatz von :

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

Sie würden es so verwenden:

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

Implementieren einer benutzerdefinierten Dienstbibliothek

Es ist im Allgemeinen verpönt, Standardobjekten in JavaScript eigene benutzerdefinierte Methoden hinzuzufügen, zum Beispiel, da dies die Kompatibilität beeinträchtigen könnte.

Wenn Sie wirklich möchten, dass Ihre eigene Methode und / oder andere benutzerdefinierte Zeichenfolgenmethoden verwendet wird, sollten Sie Ihre eigene Dienstprogrammbibliothek erstellen und dieser Bibliothek Ihre benutzerdefinierten Zeichenfolgenmethoden hinzufügen:

var helper = {};

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

Sie würden es so verwenden:

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

Verwenden einer Dienstprogrammbibliothek eines Drittanbieters

Wenn Sie keine eigene Helper-Bibliothek erstellen möchten, besteht natürlich immer die Möglichkeit, eine Dienstprogramm-Bibliothek eines Drittanbieters zu verwenden. Wie von , sind die beliebtesten Lodash und Underscore.js .

In Lodash können Sie _.includes() , das Sie wie _.includes() verwenden:

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

In Underscore.js können Sie _.str.include() , das Sie wie _.str.include() verwenden:

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

Anstatt Code-Snippets zu verwenden, die hier und dort im Web zu finden sind, können Sie auch eine bewährte und dokumentierte Bibliothek verwenden. Zwei Optionen, die ich empfehlen würde:

1. Option: Lodash : Es gibt eine Lodash Methode:

_.includes('foobar', 'ob');
// → true

Lodash ist die beliebteste Javascript-Bibliotheksabhängigkeit für npm und hat eine Menge praktischer Javascript-Dienstprogramm-Methoden. Für viele Projekte würde man das sowieso wollen ;-)

2. Option: Oder Underscore.string : Es gibt eine include Methode:

_.str.include('foobar', 'ob');
// → true

Hier ist die Beschreibung von Underscore.string, sie fügt lediglich 9kb hinzu, bietet Ihnen jedoch alle Vorteile, die eine bewährte und dokumentierte Bibliothek gegenüber copy'n'paste-Codeausschnitten bietet:

Underscore.string ist eine JavaScript-Bibliothek für komfortable Manipulation mit Strings, Erweiterung für Underscore.js, die von Prototype.js, Right.js, Underscore und schöner Ruby-Sprache inspiriert wurde.

Underscore.string bietet Ihnen mehrere nützliche Funktionen: Großschreibung, Bereinigung, Einschließen, Zählen, EscapeHTML, UnescapeHTML, Einfügen, Spleißen, StartsWith, EndesWith, Überschriften, Trimmen, Beschneiden usw.

Beachten Sie, dass Underscore.string von Underscore.js beeinflusst wird, aber auch ohne verwendet werden kann.

Last not Least: Mit der JavaScript-Version von ES6 wird eine integrierte include-Methode geliefert:

'foobar'.includes('ob');
// → true

Die meisten modernen Browser unterstützen dies bereits, haben die ES6-Kompatibilitätstabelle im Blick.


Da die Frage sehr beliebt ist, dachte ich, ich könnte dem Code ein wenig modernes Flair hinzufügen.

// 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`);

BTW, die korrekte Antwort ist falsch geschrieben indexOf oder der nicht standardmäßige String.contains . Das Laden einer externen Bibliothek (vor allem, wenn der Code in reinem JavaScript geschrieben ist) oder die Verwendung von String.prototype oder die Verwendung eines regulären Ausdrucks ist ein wenig übertrieben.


Da es eine Beschwerde über die Verwendung des Prototyps gibt und da die Verwendung von indexOf Ihren Code weniger lesbar macht, und da regexp ein Overkill ist:

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

Das ist der Kompromiss, für den ich gelaufen bin.


Das hat einfach für mich funktioniert. Es wird für Zeichenfolgen ausgewählt, die nicht den Begriff "Gelöscht:" enthalten.

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

Dieser Code sollte gut funktionieren:

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

Eine andere Möglichkeit dazu ist:

Sie können die Übereinstimmungsfunktion verwenden, d. H.

x = "teststring";

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

match () kann auch mit regulären Ausdrücken 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


Hier eine Liste der aktuellen Möglichkeiten:

1. (ES6) includes - gehe zur Antwort

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

2. ES5 und älterer indexOf

var string = "foo",
    substring = "oo";
string.indexOf(substring) !== -1;

String.prototype.indexOf gibt die Position der Zeichenfolge in der anderen Zeichenfolge zurück. Wenn nicht gefunden, wird -1 .

3. search - zur Antwort gehen

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

4. lodash beinhaltet - zur antwort gehen

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

5. RegExp - zur Antwort gehen

var string = "foo",
    expr = /oo/;  // no quotes here
expr.test(string);

6. Match - zur Antwort gehen

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

Leistungstests zeigen, dass indexOf die beste Wahl ist, wenn es auf einen Punkt ankommt, an dem Geschwindigkeit von Bedeutung ist.


In ES5

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

In ES6 gibt es drei neue Methoden: startsWith() , endsWith() , 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


JavaScript-Code für die 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 contains Methode, ob das angegebene Element im Array vorhanden ist oder nicht. Wenn das angegebene Element im Array vorhanden ist, wird true zurückgegeben, andernfalls false.


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

Syntax lautet: string.search(regexp)

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

Siehe dort Beispiele: jsref_search

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


Sie können mit dieser Anweisung leicht eine contains Methode 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, wenn Sie dies nicht verwenden. Mein Rat: Verwenden Sie Ihr eigenes Urteilsvermögen.

Alternative:

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

Sie müssen indexOf wie oben erwähnt mit einem "O" aufrufen. Es sollte auch beachtet werden, dass in JavaScript-Klasse ein reserviertes Wort ist. Sie müssen className verwenden, um dieses Datenattribut abzurufen. Der Grund dafür ist wahrscheinlich, dass er einen Nullwert zurückgibt. Sie können Folgendes tun, um Ihren Klassenwert zu erhalten ...

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

So sammeln Sie gültige Lösungen:

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


Verwenden Sie das eingebaute und das einfachste, dh match() für den String. Um das zu erreichen, worauf Sie sich freuen, tun Sie dies:

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

Wenn Sie nach einer Alternative zum Schreiben des hässlichen -1-Checks suchen, stellen Sie stattdessen eine ~ Tilde vor.

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

Joe Zimmerman - Sie werden sehen, dass Sie mit ~ on -1 den Wert 0 verwenden. Die Zahl 0 ist ein falsey-Wert, dh, der Wert wird als false ausgewertet, wenn er in einen Boolean konvertiert wird. Das mag auf den ersten Blick nicht wie ein großer Einblick erscheinen, aber erinnern Sie sich daran, dass Funktionen wie indexOf -1 zurückgeben, wenn die Abfrage nicht gefunden wird. Das bedeutet, 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, so dass Sie ihn wie folgt schreiben können:

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

Weitere Details hier


String.prototype.includes() wurde in ES6 eingeführt.

Bestimmt, ob eine Zeichenfolge in einer anderen Zeichenfolge gefunden werden kann, und gibt je nach Bedarf true oder false zurück.

Syntax

var contained = str.includes(searchString [, position]);  

Parameter

searchString

Eine Zeichenfolge, nach der innerhalb dieser Zeichenfolge gesucht werden soll.

position

Die Position in dieser Zeichenfolge, an der die Suche nach searchString beginnen soll, searchString standardmäßig 0.

Beispiel

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  

Hinweis

In älteren Browsern kann dies ein ES6-Shim erfordern.


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 gebräuchliche 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 (Falsey) umzuwandeln, und alle anderen Werte sind ungleich Null (wahr).

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







string-matching