In this article, we will explore the different ways to check if a string contains a substring in JavaScript, and compare their performance and efficiency.

Method 1: String.prototype.includes()

The first method we will explore is the String.prototype.includes() method. This method returns a boolean value indicating whether the given string contains the specified substring. The syntax for this method is as follows:

				
					string.includes(searchString, [position]);

The searchString parameter is the substring that you want to search for, and the position parameter is an optional argument that specifies the index at which to start searching. If this parameter is not provided, the search will start at the beginning of the string.

Here’s an example of using the includes() method to check if a string contains a substring:

Method 2: String.prototype.indexOf()

Another standard method for checking if a string contains a substring is the String.prototype.indexOf() method. This method returns the index of the first occurrence of the specified substring within the string, or -1 if the substring is not found. The syntax for this method is as follows:

				
					string.indexOf(searchValue, [fromIndex]);

The searchValue parameter is the substring you want to search for, and the fromIndex parameter is an optional argument that specifies the index at which to start searching. If this parameter is not provided, the search will begin at the beginning of the string.

Here’s an example of using the indexOf() method to check if a string contains a substring:

				
					let str = "Hello, World!";
let substring = "Hello";

console.log(str.indexOf(substring) !== -1); // returns true

Method 3: Regular Expressions

Another way to check if a string contains a substring is through regular expressions. Regular expressions are a powerful tool for pattern matching in strings, and can be used to check if a string contains a substring with a specified pattern. The syntax for using regular expressions in JavaScript is as follows:

				
					RegExp(/pattern/[, flags]);

The pattern parameter is a string that specifies the pattern to search for, and the flags parameter is an optional argument that specifies additional options for the regular expression. The most common flag used in this context is the g flag, which sets a global search.

Here’s an example of using regular expressions to check if a string contains a substring:

				
					let str = "Hello, World!";
let substring = "Hello";

console.log(RegExp(substring).test(str)); // returns true

Performance Comparison

So which method is the best for checking if a string contains a substring in JavaScript?
The answer to this question depends on the specific use case, but the includes() method is generally includes() method is the most efficient and recommended method. It has a linear time complexity and is the quickest method for small strings. On the other hand, the indexOf() method also has a linear time complexity, but it can become slower as the series grows in size. While powerful, regular expressions are also slower than the includes() methodincludes() method, and should only be used when a complex pattern matching is needed.

Additionally, it is essential to note that the performance of these methods can also be affected by other factors such as the size of the substring, the type of data being searched, and the specific JavaScript engine being used.

In conclusion, the best method for checking if a string contains a substring in JavaScript will vary depending on the specific use case and the complexity of the searched data. However, the includes() method is a reliable and efficient solution for most casesincludes() method is a reliable and efficient solution.


Thanks for reading. Happy coding!