How to Check if a String Contains a Substring in JavaScript

Strings are an important part of any programming language, including JavaScript. Strings are a sequence of characters that are used to represent text. In JavaScript, strings are primitive data types and can be manipulated in a variety of ways. One common task when working with strings is to check whether a string contains a substring. In this blog post, we will explore different ways of checking whether a string contains a substring in JavaScript, with code examples.

1. Using indexOf()

The indexOf() method is a built-in JavaScript function that returns the index of the first occurrence of a substring within a string. If the substring is not found, the method returns -1. Here is an example:

const str = "Hello, world!";
const substr = "world";
const index = str.indexOf(substr);
if (index !== -1) {
  console.log(`The substring "${substr}" was found at index ${index}.`);
} else {
  console.log(`The substring "${substr}" was not found.`);
}

In the example above, we create a string str and a substring substr. We then call the indexOf() method on the str variable, passing in the substr variable as an argument. If the method returns a value other than -1, we know that the substring was found in the string.

2. Using includes()

The includes() method is another built-in function that checks whether a string contains a substring. Unlike the indexOf() method, includes() returns a boolean value. Here is an example:

const str = "Hello, world!";
const substr = "world";
const isSubstring = str.includes(substr);
if (isSubstring) {
  console.log(`The substring "${substr}" was found.`);
} else {
  console.log(`The substring "${substr}" was not found.`);
}

In the example above, we create a string str and a substring substr. We then call the includes() method on the str variable, passing in the substr variable as an argument. If the method returns true, we know that the substring was found in the string.

3. Using RegExp

Regular expressions, or RegExp for short, are a powerful tool for working with strings in JavaScript. A regular expression is a pattern that can be used to match and manipulate strings. Here is an example of using a regular expression to check whether a string contains a substring:

const str = "Hello, world!";
const substr = "world";
const pattern = new RegExp(substr);
const isSubstring = pattern.test(str);
if (isSubstring) {
  console.log(`The substring "${substr}" was found.`);
} else {
  console.log(`The substring "${substr}" was not found.`);
}

In the example above, we create a string str, a substring substr, and a regular expression pattern that matches the substr. We then call the test() method on the pattern variable, passing in the str variable as an argument. If the method returns true, we know that the substring was found in the string.

4. Using String.prototype.match()

The match() method is a built-in function in JavaScript that returns an array of matches of a string against a regular expression. Here is an example:

const str = "Hello, world!";
const substr = "world";
const pattern = new RegExp(substr);
const matches = str.match(pattern);
if (matches) {
  console.log(`The substring "${substr}" was found.`);
} else {
  console.log(`The substring "${substr}" was not found.`);
}

In the example above, we create a string str, a substring substr, and a regular expression pattern that matches the substr. We then call the match() method on the str variable, passing in the pattern variable as an argument. If the method returns an array with at least one element, we know that the substring was found in the string.

5. Using String.prototype.search()

The search() method is another built-in function in JavaScript that returns the index of the first match of a string against a regular expression. Here is an example:

const str = "Hello, world!";
const substr = "world";
const pattern = new RegExp(substr);
const index = str.search(pattern);
if (index !== -1) {
  console.log(`The substring "${substr}" was found at index ${index}.`);
} else {
  console.log(`The substring "${substr}" was not found.`);
}

In the example above, we create a string str, a substring substr, and a regular expression pattern that matches the substr. We then call the search() method on the str variable, passing in the pattern variable as an argument. If the method returns a value other than -1, we know that the substring was found in the string.

6. Using ES6 includes()

ES6 introduced a new way of checking whether a string contains a substring, the includes() method. This method is similar to the built-in includes() method we looked at earlier, but it has some additional features. Here is an example:

const str = "Hello, world!";
const substr = "world";
const isSubstring = str.includes(substr);
if (isSubstring) {
  console.log(`The substring "${substr}" was found.`);
} else {
  console.log(`The substring "${substr}" was not found.`);
}

In the example above, we create a string str and a substring substr. We then call the includes() method on the str variable, passing in the substr variable as an argument. If the method returns true, we know that the substring was found in the string.

Conclusion

In this blog post, we explored different ways of checking whether a string contains a substring in JavaScript, with code examples. We looked at using the indexOf() and includes() methods, regular expressions, the match() and search() methods, and the ES6 includes() method. Each of these methods has its own strengths and weaknesses, and the best choice will depend on the specific use case. By understanding these different methods, you can become a more effective and efficient JavaScript programmer.

 

Leave a Reply