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

Question

This question's answers are a community effort . Edit existing answers to improve this post. It is not currently accepting new answers or interactions.

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?

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

• Gavin: 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.
• Ry-: @Aashiq: Yes, an empty string is a substring of every string.
• Davo: @Gavin 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)
• KWallace: Why is a discussion of case sensitivity even taking place here?
• Ry-: @uingtea: wrong

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

• user128511: just curious, why do you need to check the length? Does IE fail in that case or something?
• user128511: 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
• The Empty String Photographer: I don't think it's easy to use Internet Explorer right now.

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

• sphoenix: 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)
• wz366: KMP provides linear O(n) performance here.
• TheLebDev: @wz366 KMP provides O(n), what about the rest? Any Idea?
• dandavis: If this is used for speed, it would likely run faster if you replaced .charAt(i) with [i] to avoid the extra function calls.
• Clint Eastwood: 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?