Check if a String contains a Substring in JavaScript

# Check if a String contains a Substring with String.includes()

Use the String.includes() method to check if a string contains a substring.

The String.includes() method returns true if the substring is contained in the string, otherwise false is returned.

Copied!
const string = 'hello world';
const substring = 'hello';

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

if (string.includes(substring)) {
  // 👉️ substring is contained in the string
}

We used the String.includes() method to check if a substring is contained in a string.

If the substring is contained in the string, the String.includes() method returns true, otherwise it returns false.

The String.includes() method is case-sensitive. To do a case-insensitive check if a substring is contained in a string, convert both strings to lowercase.

Copied!
const string = 'HELLO world';
const substring = 'hello';

// 👇️ true
console.log(
  string.toLowerCase().includes(substring.toLowerCase())
);

if (string.toLowerCase().includes(substring.toLowerCase())) {
  // 👉️ substring is contained in the string
}

# Check if String Doesn't contain a Substring in JavaScript

Use the logical NOT (!) operator to negate the call to the includes() method to check if a string doesn't contain a substring.

The expression will return true if the string doesn't contain the substring and false otherwise.

Copied!
const str = 'hello world';

if (!str.includes('bye')) {
  console.log('✅ string does not include substring');
} else {
  console.log('⛔️ string includes substring');
}

We used the logical NOT (!) operator to negate the call to the String.includes() method.

In the example, we check if the value bye is contained in the string hello world.

Copied!
const str = 'hello world';

console.log(str.includes('bye')); // 👉️ false

console.log(!str.includes('bye')); // 👉️ true

If we use the includes() method without the logical NOT (!) operator, it returns true if the value is contained in the string and false otherwise.

If you need to check if a string doesn't contain a substring in a case-insensitive manner, convert both strings to lowercase.

Copied!
function notContains(string, substring) {
  return !str.toLowerCase().includes(substring.toLowerCase());
}

const str = 'hello world';

console.log(notContains(str, 'BYE')); // 👉️ true
console.log(notContains(str, 'HEL')); // 👉️ false

We used the String.toLowerCase() method to convert both strings to lowercase before checking if the string doesn't contain the substring.

Here are some more examples of using the logical NOT (!) operator.

Copied!
console.log(!true); // 👉️ false
console.log(!false); // 👉️ true

console.log(!'hello'); // 👉️ false
console.log(!''); // 👉️ true
console.log(!null); // 👉️ true

You can imagine that the logical NOT (!) operator first converts the value to a boolean and then flips the value.

Falsy values are: null, undefined, empty string, NaN, 0 and false.

# Check if a String contains a Substring with String.indexOf()

This is a three-step process:

1. Call the indexOf method on the string, passing it the substring as a parameter.
2. Conditionally check if the returned value is not equal to -1.
3. If the returned value is not equal to -1, the string contains the substring.

Copied!
const string = 'hello world';
const substring = 'hello';

const index = string.indexOf(substring);
console.log(index); // 👉️ 0

if (string.indexOf(substring) !== -1) {
  // 👉️ substring is contained in the string
}

The substring in the code sample is contained in the string starting at index 0. Therefore the indexOf method returns 0.

Our if block is only run if the String.indexOf method doesn't return -1. The method only returns -1 if the substring is not contained in the string.

# Check if String Doesn't contain a Substring using indexOf()

This is a two-step process:

1. Use the String.indexOf() method to get the index of the substring in the string.
2. If the indexOf() method returns -1, the string doesn't contain the substring.

Copied!
const str = 'hello world';

if (str.indexOf('bye') === -1) {
  console.log('✅ string does not include substring');
} else {
  console.log('⛔️ string includes substring');
}

The String.indexOf method returns the index of the first occurrence of a substring in a string.

If the substring is not contained in the string, the method returns -1.

If you need to check if a string doesn't contain a substring in a case-insensitive manner, convert both strings to lowercase.

Copied!
function notContains(string, substring) {
  return string.toLowerCase().indexOf(substring.toLowerCase()) === -1;
}

const str = 'hello world';

console.log(notContains(str, 'BYE')); // 👉️ true
console.log(notContains(str, 'HEL')); // 👉️ false

We can check if a string doesn't contain a substring in a case-insensitive manner by converting the two strings to the same case.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• Check if a String contains Numbers in JavaScript
• Check if String contains only Letters and Numbers in JS
• Check if a String contains Spaces in JavaScript
• Check if String contains Special Characters in JavaScript
• TypeError: Cannot use 'in' operator to search for 'X' in 'Y'