How to check if a string contains a substring in JavaScript

1includes()Recommended

text.includes(search) returns a boolean, so it drops straight into an if with nothing to compare against. An optional second argument sets the index to start searching from. For the negative check, write !text.includes("x").

const text = "CompileBytes runs your code in the browser";

if (text.includes("code")) {
  console.log("found it");
}

console.log(text.includes("browser"));
console.log(text.includes("Python"));
console.log(text.includes("Code"));

// Optional second argument: the index to start searching from
console.log(text.includes("code", 25));

// Every string contains the empty string
console.log(text.includes(""));

// A value that might be null or undefined? Use ?. and a default
const title = null;
console.log(title?.includes("code") ?? false);

Output: found it, true, false, false, false, true, false. The fourth line is the usual surprise: "Code" misses the lowercase code, because includes() compares exact characters (section 4 fixes that). The fifth is false because code starts at index 23 and the search began at 25. An empty needle always matches, so check for "" first if it comes from user input. Calling includes() on null throws a TypeError, which is why the last line uses ?. and ?? false.

2startsWith() and endsWith()

includes() matches anywhere, which is the wrong question for file extensions, URL schemes and path prefixes. startsWith() anchors the match to the start and endsWith() to the end. Both take an optional second argument: startsWith reads it as the index to begin at, and endsWith as the length to treat as the end of the string.

const path = "images/logo.png";

console.log(path.startsWith("images/"));
console.log(path.endsWith(".png"));

// includes() says yes to a name that merely mentions .png
const tricky = "logo.png.txt";
console.log(tricky.includes(".png"), tricky.endsWith(".png"));

// Second argument: where startsWith begins, where endsWith stops
console.log(path.startsWith("logo", 7));
console.log(path.endsWith("logo", 11));

// Several candidates? Combine with some()
const imageTypes = [".png", ".jpg", ".webp"];
console.log(imageTypes.some((ext) => path.endsWith(ext)));

Output: true, true, true false, true, true, true. The third line is why these methods exist: logo.png.txt is a text file, and only endsWith() gets that right. path.endsWith("logo", 11) is true because it only looks at the first 11 characters, images/logo. Neither method accepts an array, so for several candidates pass a callback to some(). Extensions can arrive in upper case, so lowercase the path first if .PNG should count.

3indexOf(), when you need the position

indexOf() returns the index of the first match, or -1 when there is none. lastIndexOf() searches from the end. Use them when you need the position, for example to slice around the match. Before includes() existed, indexOf(x) !== -1 was the contains check, and that idiom has one bug that keeps turning up.

const text = "CompileBytes runs your code in the browser";

console.log(text.indexOf("code"));
console.log(text.indexOf("Python"));
console.log(text.lastIndexOf("r"));

// The pre-ES2015 contains check
console.log(text.indexOf("code") !== -1);

// The classic bug: a match at index 0 is falsy
if (text.indexOf("Compile")) {
  console.log("found Compile");
} else {
  console.log("missed Compile, which is at index", text.indexOf("Compile"));
}

// Old prefix and suffix idioms that startsWith/endsWith replaced
console.log(text.lastIndexOf("Compile", 0) === 0);
console.log(text.slice(-"browser".length) === "browser");

Output: 23, -1, 41, true, then missed Compile, which is at index 0, true, true. The if fails because indexOf() returns 0 for a match at the very start, and 0 is falsy, while a miss returns -1, which is truthy. Always compare against -1, or better, use includes(). The last two lines are the old startsWith and endsWith workarounds. They work, but the named methods say what you mean. You may also see ~text.indexOf(x) in old code, a bitwise trick that turns -1 into 0. It works, but it is hard to read.

4Ignoring case

includes(), startsWith(), endsWith() and indexOf() have no ignore-case option. To search, lowercase both sides and search that. To compare two whole strings, toLowerCase() on both works for plain text, but localeCompare() with a sensitivity option is the Unicode-aware answer: "accent" ignores case only, and "base" ignores accents too.

const text = "CompileBytes Runs Your Code";
const needle = "runs";

console.log(text.includes(needle));
console.log(text.toLowerCase().includes(needle.toLowerCase()));

// Comparing two whole strings, ignoring case
const a = "résumé";
const b = "RÉSUMÉ";
console.log(a.toLowerCase() === b.toLowerCase());
console.log(a.localeCompare(b, "en", { sensitivity: "accent" }) === 0);
console.log(a.localeCompare("resume", "en", { sensitivity: "accent" }) === 0);
console.log(a.localeCompare("resume", "en", { sensitivity: "base" }) === 0);

// Case mapping can change length: ß upper-cases to SS
console.log("Straße".toUpperCase());
console.log("Straße".toLowerCase() === "STRASSE".toLowerCase());
console.log("Straße".toUpperCase() === "STRASSE".toUpperCase());

// Some languages lowercase differently: Turkish has a dotless ı
console.log("TITLE".toLowerCase(), "TITLE".toLocaleLowerCase("tr"));

Output: false, true, true, true, false, true, STRASSE, false, true, title tıtle. The two localeCompare lines on resume show the difference between the options: with "accent" the accents still count, so the result is false, and with "base" they don't, so it is true. The ß lines show why simple case mapping is not a full answer: Straße and STRASSE are equal in upper case but not in lower case. The last line is the Turkish problem: in the tr locale, a capital I lowercases to a dotless ı, so use toLocaleLowerCase() when you know the text's language. If you compare many strings, build one Intl.Collator with the same options and reuse its compare method.

5Regular expressions, when the needle is a pattern

When you are looking for a shape (a date, a number, a whole word) rather than fixed text, use a regular expression. regex.test(text) is the boolean check, text.search(regex) returns the position, and text.match(regex) returns what matched. The i flag ignores case and \b marks a word boundary.

const log = "ERROR 2026-09-24 disk usage at 91%";

// includes() only takes text, never a pattern
try {
  log.includes(/ERROR/);
} catch (err) {
  console.log(`${err.name}: ${err.message}`);
}

// A shape, not a fixed substring
console.log(/\d{4}-\d{2}-\d{2}/.test(log));
console.log(log.search(/\d/), log.match(/\d+%/)[0]);

// Ignore case, and match whole words only
console.log(/\berror\b/i.test("Fatal Error: disk full"));
console.log(/\berror\b/i.test("no errors here"));

// Needle from user input? Escape it (RegExp.escape, ES2025)
const version = "1.5.0";
console.log(new RegExp(version).test("v1x5y0"));
console.log(new RegExp(RegExp.escape(version)).test("v1x5y0"));

// Any of several needles in one pass
const keywords = ["timeout", "panic", "segfault"];
const anyKeyword = new RegExp(keywords.map(RegExp.escape).join("|"));
console.log(anyKeyword.test("the deploy failed with a timeout"));

// Gotcha: a /g regex remembers lastIndex between test() calls
const re = /code/g;
console.log(re.test("code"), re.test("code"));

The first line prints TypeError: First argument to String.prototype.includes must not be a regular expression: includes(), startsWith() and endsWith() refuse regex arguments rather than quietly converting them to text. Then true, 6 91%, and true, false: \b keeps errors from counting as error. The escaping lines print true then false. Unescaped, each . in 1.5.0 matches any character, so v1x5y0 matches. Next, true for the keyword list, and last true false. With the g flag, test() resumes from lastIndex, so the second call on the same string fails. Drop g for yes-or-no checks. RegExp.escape is new in ES2025. On older engines, escape with s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").

6Which should you use?