Wie prüft man in JavaScript, ob eine Zeichenkette eine Teilzeichenkette enthält?

Question

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

Wie lässt sich dies sinnvoll überprüfen?

Answer 1

ECMAScript 6 eingeführt String.prototype.includes :

const string = "foo";
const substring = "oo";

console.log(string.includes(substring)); // true

includes keine Unterstützung für den Internet Explorer hat Allerdings. In ECMAScript 5 oder älteren Umgebungen, verwenden Sie String.prototype.indexOf , die -1 zurückgibt, wenn eine Teilzeichenkette nicht gefunden wird:

var string = "foo";
var substring = "oo";

console.log(string.indexOf(substring) !== -1); // true

Answer 2

Es gibt eine String.prototype.includes in ES6 :

"potato".includes("to");
> true

Beachten Sie, dass diese funktioniert nicht im Internet Explorer oder einigen anderen alten Browsern mit keiner oder unvollständiger ES6-Unterstützung. Damit es in alten Browsern funktioniert, können Sie einen Transpiler verwenden wie Babel eine Unterlegscheibenbibliothek wie es6-shim oder dies Polyfill von MDN :

if (!String.prototype.includes) {
  String.prototype.includes = function(search, start) {
    'use strict';
    if (typeof start !== 'number') {
      start = 0;
    }

    if (start + search.length > this.length) {
      return false;
    } else {
      return this.indexOf(search, start) !== -1;
    }
  };
}

Answer 3

Eine weitere Alternative ist KMP (Knuth-Morris-Pratt).

Der KMP-Algorithmus sucht nach einer Längen- m Teilzeichenfolge in einer Längen- n Zeichenfolge im schlimmsten Fall O( n + m ) Zeit, verglichen mit einem Worst-Case von O( n m ) für den naiven Algorithmus, so dass die Verwendung von KMP sinnvoll sein kann, wenn Sie sich um die Worst-Case-Zeitkomplexität kümmern.

Hier ist eine JavaScript-Implementierung des Projekts Nayuki, die aus https://www.nayuki.io/res/knuth-morris-pratt-string-matching/kmp-string-matcher.js :

// Searches for the given pattern string in the given text string using the Knuth-Morris-Pratt string matching algorithm.
// If the pattern is found, this returns the index of the start of the earliest match in 'text'. Otherwise -1 is returned.

function kmpSearch(pattern, text) {
  if (pattern.length == 0)
    return 0; // Immediate match

  // Compute longest suffix-prefix table
  var lsp = [0]; // Base case
  for (var i = 1; i < pattern.length; i++) {
    var j = lsp[i - 1]; // Start by assuming we're extending the previous LSP
    while (j > 0 && pattern.charAt(i) != pattern.charAt(j))
      j = lsp[j - 1];
    if (pattern.charAt(i) == pattern.charAt(j))
      j++;
    lsp.push(j);
  }

  // Walk through text string
  var j = 0; // Number of chars matched in pattern
  for (var i = 0; i < text.length; i++) {
    while (j > 0 && text.charAt(i) != pattern.charAt(j))
      j = lsp[j - 1]; // Fall back in the pattern
    if (text.charAt(i) == pattern.charAt(j)) {
      j++; // Next char matched, increment position
      if (j == pattern.length)
        return i - (j - 1);
    }
  }
  return -1; // Not found
}

console.log(kmpSearch('ays', 'haystack') != -1) // true
console.log(kmpSearch('asdf', 'haystack') != -1) // false