How to check whether a string contains a substring in JavaScript?

Question

Usually I would expect a String.contains() method, but there doesn't seem to be one.

What is a reasonable way to check for this?

Landry

Answer 1

ECMAScript 6 introduced String.prototype.includes:

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

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

String.prototype.includes is case-sensitive and is not supported by Internet Explorer without a polyfill.

In ECMAScript 5 or older environments, use String.prototype.indexOf, which returns -1 when a substring cannot be found:

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

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

Juicy

While this is a good answer, and the OP never requested for a "case-sensitive" search, it should be noted that includes performs a case-sensitive search. – Abscess

@Aashiq: Yes, an empty string is a substring of every string. – Juicy

@Abscess by default if I want to know if something is a substring, I imagine it would be case-sensitive. After all, "A" and "a" are different characters. The OP never requested a "case-insensitive" search ( which is a trivial solution, if you make everything lowercase) – Northeasterly

indexOf is also case case-sensitive search, so both includes and indexOf are case-sensitive . – Palisade

Why is a discussion of case sensitivity even taking place here? – Tooth

what is the complexity of javascript implementation of string.indexOf()? – Cassilda

In 'C' a string is just an array of char. Is there a solution for strstr on an array of any type of object? Let's say of a specific type, as in Uint8Array? – Lamonicalamont

@MaxWaterman: Nothing built-in. Options include converting to a string (String.fromCharCode(...array).includes(String.fromCharCode(...subarray))) or implementing a string search algorithm for arrays (e.g. KMP as seen in another answer here). – Juicy

@Juicy Shame. I know about solutions in JavaScript, but they all (seem to) involve copying the array or implementing a search JS-side, which is what we're trying to avoid. It seems like a curious omission :/ – Lamonicalamont

the funnys thing about .includes(); Previously it name was .contains() like C#, it name was proposed for many years and maybe since javascript born, but people with high authority in JS hate so much MSoft so it renamed to includes – Coacher

@uingtea: wrong – Juicy

@Tooth a significant amount of freshly hatched newblet developers are coming from a case-insensitive-by-default world. It's overwhelmingly and increasingly common in higher-level UI/UX to do things case-insensitive by default. To you and me and the rest of us lost-in-the-sauce fluent-in-programming nerds, it's so obvious that case sensitivity is expected that "is this a substring of that?" automatically implies an assumption of case sensitivity without a conscious question/thought that it could be otherwise, but to anyone who hasn't yet learned to expect that, it really is worth mentioning. – Delay

Answer 2

There is a String.prototype.includes in ES6:

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

Note that this does not work in Internet Explorer or some other old browsers with no or incomplete ES6 support. To make it work in old browsers, you may wish to use a transpiler like Babel, a shim library like es6-shim, or this polyfill from 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;
    }
  };
}

Noticeable

just curious, why do you need to check the length? Does IE fail in that case or something? – Kiyokokiyoshi

Also the checking for number fails to perform like includes. Example: es6 includes returns false for "abc".includes("ab", "1") this polyfill will return true – Kiyokokiyoshi

Answer 3

Another alternative is KMP (Knuth–Morris–Pratt).

The KMP algorithm searches for a length-m substring in a length-n string in worst-case O(n+m) time, compared to a worst-case of O(n⋅m) for the naive algorithm, so using KMP may be reasonable if you care about worst-case time complexity.

Here's a JavaScript implementation by Project Nayuki, taken from 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[i] !== pattern[j])
      j = lsp[j - 1];
    if (pattern[i] === pattern[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[i] != pattern[j])
      j = lsp[j - 1]; // Fall back in the pattern
    if (text[i]  == pattern[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

Voguish

Not questioning anything on this approach... but why implementing KMP where there's a includes or indexOf on the table. (Although the underneath impl of those maybe using KMP... not sure) – Fernando

KMP provides linear O(n) performance here. – Drusilla

@Drusilla KMP provides O(n), what about the rest? Any Idea? – Absorptance

If this is used for speed, it would likely run faster if you replaced .charAt(i) with [i] to avoid the extra function calls. – Some

99% of the times, doing this is overkill and harmful for non-computational aspects of a software project. Unless you're working on something extremely critical, I strongly advise against following this path... I don't think that big players like Twitter, Facebook, or most of Google products would even use this... so why should you? – Inhaul

@ClintEastwood: This same approach works on things that aren’t JavaScript strings, which can be useful in all sorts of applications. (You should probably import it from a package if you need it, though, instead of embedding a copy from a Stack Overflow answer.) “Extremely critical” isn’t the right distinction. – Juicy