JavaScript includes(): Syntax, Usage, and Examples

The includes() method in JavaScript checks whether a given value exists in a string or array. It returns a simple true or false depending on whether the value is found. JavaScript includes is often used for validation, filtering, and quick membership checks without having to loop through data manually. The method is clean, concise, and extremely useful in both array and string contexts.

How to Use JavaScript includes

The includes() method has two main use cases—arrays and strings. Here's the general syntax:

For arrays:

array.includes(searchElement, fromIndex)

For strings:

string.includes(searchValue, position)

• searchElement / searchValue: The item or substring you want to search for.
• fromIndex / position: Optional. Where the search starts. Default is 0.

Both versions return true if the value is found, otherwise false.

Basic Examples

const colors = ["red", "blue", "green"];
console.log(colors.includes("blue")); // true

const sentence = "JavaScript is awesome";
console.log(sentence.includes("awesome")); // true

When to Use includes JavaScript

JavaScript includes is your go-to method when you want to:

Check If an Array Contains a Value

const fruits = ["apple", "banana", "cherry"];
const hasBanana = fruits.includes("banana");

if (hasBanana) {
  console.log("Banana is in the list!");
}

This avoids writing a for loop or using indexOf() with comparisons.

Test Substrings Within Text

const note = "This message contains important info";

if (note.includes("important")) {
  highlightNote(note);
}

Use it to trigger actions based on user input, log messages, or dynamic content.

Perform Validation Logic

const allowedRoles = ["admin", "editor"];
const role = "guest";

if (!allowedRoles.includes(role)) {
  console.log("Access denied.");
}

It simplifies permission checks and access control.

Examples of JavaScript includes in Action

With Arrays

const numbers = [10, 20, 30, 40];

console.log(numbers.includes(20));      // true
console.log(numbers.includes(100));     // false
console.log(numbers.includes(30, 3));   // false (starts checking at index 3)

Only the values found at or after the starting index are checked.

With Strings

const title = "Mastering JavaScript in 30 Days";

console.log(title.includes("JavaScript")); // true
console.log(title.includes("Python"));     // false
console.log(title.includes("Java", 5));    // true

The method respects the order and spacing of characters exactly.

Learn More About the JavaScript includes Method

Case Sensitivity

The method is case-sensitive for both strings and arrays:

const pets = ["Dog", "Cat", "Parrot"];
console.log(pets.includes("dog")); // false

To do a case-insensitive check, normalize both values:

pets.map(p => p.toLowerCase()).includes("dog"); // true

Alternative to indexOf

Before includes(), developers used indexOf():

if (fruits.indexOf("apple") !== -1) {
  // Apple is present
}

Today, .includes() replaces that with cleaner syntax:

if (fruits.includes("apple")) {
  // Apple is present
}

Use indexOf() when you need the exact position; use includes when all you need is a yes or no.

Using .includes JavaScript With Objects and Complex Types

When checking arrays of objects, includes won't work as expected:

const users = [{ name: "Alice" }, { name: "Bob" }];
console.log(users.includes({ name: "Alice" })); // false

Because each object is a different reference in memory, includes can't match them.

Instead, use some() or find():

const hasAlice = users.some(user => user.name === "Alice");

That lets you search based on object values.

Includes in JavaScript Strings with Conditions

You can use includes to build filters:

const comments = [
  "Great product!",
  "Terrible customer service",
  "Product arrived late",
  "Fantastic value!"
];

const flagged = comments.filter(comment =>
  comment.toLowerCase().includes("terrible")
);

console.log(flagged); // ["Terrible customer service"]

This is useful for moderation tools, keyword highlighting, and search features.

Nested Checks with Multiple Values

To check if a string includes one of several keywords:

const keywords = ["error", "failed", "timeout"];
const logMessage = "Server timeout detected";

const matched = keywords.some(keyword => logMessage.includes(keyword));

console.log(matched); // true

This lets you scale from one check to many, using includes behind the scenes.

Limitations and Quirks

• Doesn’t work on IE (Internet Explorer) without a polyfill.
• Works best for primitive values—objects and arrays are not matched by value.
• You can’t use regular expressions. For pattern-based searches, use .match() or .test().

JavaScript includes String Validation in Forms

Validate user input cleanly:

const input = "myusername@example.com";

if (!input.includes("@")) {
  showError("Email must contain '@'");
}

Simplifies validation without needing regex for every case.

JavaScript Array includes with Numbers and Booleans

You can also check for numbers or booleans in arrays:

const options = [true, false];
console.log(options.includes(true)); // true

const ages = [18, 21, 30];
console.log(ages.includes(21));      // true

As long as the values are primitives, includes works perfectly.

The JavaScript includes method helps you quickly determine if a string contains a substring or if an array contains a value. It’s an essential tool in modern JavaScript—cleaner than index-based methods, easier to read, and ideal for conditions, filters, and validation. Whether you're scanning for keywords, checking roles, or validating form fields, includes in JavaScript keeps your logic concise and expressive.