How to Check if a String Contains a Substring in JavaScript

By the end of this page, you will understand how to check whether a string contains a substring in JavaScript, when to use includes() versus indexOf(), how case sensitivity works, and what patterns developers commonly use in real code.

In JavaScript, checking whether a string contains a substring means asking:

• Does this larger string include this smaller piece of text?
• If yes, return true
• If no, return false

This is a very common operation in programming. You use it when:

• validating user input
• searching text
• filtering data
• checking file paths or URLs
• parsing messages or logs

The modern and most readable way to do this in JavaScript is String.prototype.includes().

const text = "Hello world";
console.log(text.includes("world")); // true

Before includes() became common, developers often used indexOf().

const text = "Hello world";
console.log(text.indexOf("world") !== -1); // true

Both approaches work, but includes() is easier to read because it directly expresses the intent: checking whether the substring exists.

Think of a string like a sentence written on paper.

• The full string is the whole sentence.
• The substring is a word or phrase you are trying to spot.
• includes() is like asking: “Can I find this word anywhere in the sentence?”
• indexOf() is like asking: “At what character position does this word begin?”

If you only care whether it exists, use includes(). If you also care where it appears, use indexOf().

Basic syntax

Using includes()

string.includes(searchString)
string.includes(searchString, startPosition)

• searchString: the substring to look for
• startPosition: optional index to start searching from
• returns true or false

Example:

const text = "JavaScript is fun";

console.log(text.includes("Script")); // true
console.log(text.includes("Python")); // false

This is the clearest way to test for a substring.

Using indexOf()

string.indexOf(searchString)
string.indexOf(searchString, startPosition)

Consider this example:

const text = "Hello world";
const result = text.includes("world");
console.log(result);

Step by step:

1. text stores the string "Hello world".
2. JavaScript evaluates text.includes("world").
3. It scans the string looking for the exact sequence of characters w, o, r, l, d.
4. It finds that sequence starting at index 6.
5. Because the substring exists, includes() returns true.
6. result now stores true.
7. console.log(result) prints true.

Now compare with :

Checking for substrings appears in many real programs.

Search input filtering

const productName = "Wireless Mouse";
const query = "mouse";

const matches = productName.toLowerCase().includes(query.toLowerCase());

Used in search bars and product filters.

Email validation shortcuts

const email = "user@example.com";
const looksLikeEmail = email.includes("@");

This is not full validation, but it can be part of a quick check.

URL or route checks

const url = "/admin/dashboard";

if (url.includes("/admin")) {
  console.log("Admin route");
}

Useful in routing or permission logic.

Log analysis

const logLine = ;

 (logLine.()) {
  .();
}

In real codebases, substring checks are often part of larger patterns.

Guard clauses

Developers often exit early when required text is missing.

function processMessage(message) {
  if (!message.includes("#")) {
    return "Missing tag";
  }

  return "Valid message";
}

This keeps functions simple and readable.

Input normalization

Case-insensitive matching is very common.

function containsKeyword(text, keyword) {
  return text.toLowerCase().includes(keyword.toLowerCase());
}

This prevents failures caused by uppercase/lowercase differences.

Filtering arrays of strings

const users = ["Alice", "Bob", "Charlie"];
const query = "li";

const results = users.filter(
  name.().(query.())
);

.(results); 

1. Trying to use contains()

JavaScript strings do not use contains().

Broken code:

const text = "Hello world";
console.log(text.contains("world"));

Use this instead:

const text = "Hello world";
console.log(text.includes("world"));

2. Forgetting that indexOf() returns 0 for matches at the start

Broken code:

const text = "hello world";

if (text.indexOf("hello")) {
  console.log("Found");
}

Why this fails:

• indexOf("hello") returns

Quick reference

Check if substring exists

str.includes("text")

Check from a starting index

str.includes("text", startIndex)

Older alternative

str.indexOf("text") !== -1

Case-insensitive check

str.toLowerCase().includes(search.toLowerCase())

Useful related methods

str.startsWith("text")
str.endsWith("text")

Rules to remember

• includes() returns true or false
• indexOf() returns a number or

How do I check if a string contains a substring in JavaScript?

Use includes():

"Hello world".includes("world"); // true

Is there a String.contains() method in JavaScript?

No. The standard method is includes().

What is the difference between includes() and indexOf()?

• includes() returns true or false
• indexOf() returns the starting position or -1

Is includes() case-sensitive?

Yes.

"Hello".includes("hello"); // false

How do I do a case-insensitive contains check?

• String methods — includes(), indexOf(), startsWith(), and endsWith() are all part of everyday string handling.
• Case sensitivity — substring checks often fail because uppercase and lowercase letters are treated differently.
• Regular expressions — useful when simple substring matching is not flexible enough.
• Conditional statements — substring checks are often used inside if statements.
• Array filtering — search features often combine includes() with filter().
• Input validation — checking for required text is a common validation step.
• Type conversion — sometimes values must be converted to strings before searching them.