Multiple Approaches to Check if a String Contains Any Substring from an Array in JavaScript

Array some Method for Substring Checking

In JavaScript, checking whether a string contains any substring from an array is a common programming requirement. Although JavaScript doesn't provide a built-in direct method, this functionality can be elegantly implemented using the array some method.

The some method, introduced in ES5, is an array prototype method that executes a provided test function on each array element until it finds one where the function returns true. If such an element is found, some immediately returns true; otherwise, it returns false. This short-circuit evaluation feature gives it performance advantages.

Basic Implementation

Using traditional function expressions:

if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
    // At least one matching substring exists
}

This approach utilizes the indexOf method to check for substring presence, where a return value greater than or equal to 0 indicates a match was found.

ES6 Arrow Functions and includes Method

With the widespread adoption of ES6, we can use more concise arrow functions and the includes method:

if (substrings.some(v => str.includes(v))) {
    // At least one matching substring exists
}

The includes method is more intuitive than indexOf, directly returning a boolean value and avoiding comparison operations with -1. This approach results in cleaner, more readable code.

Practical Application Example

Consider a real-world scenario: we need to check if a document title contains specific keywords. Assuming we have a keyword array ["invoice", "order", "project"], we can implement it as follows:

const keywords = ["invoice", "order", "project"];
const documentTitle = "Q4 2023 Invoice Summary";

if (keywords.some(keyword => documentTitle.includes(keyword))) {
    console.log("Document contains relevant keywords");
    // Execute corresponding business logic
} else {
    console.log("Document does not contain relevant keywords");
}

Regular Expression Approach

Another implementation method involves using regular expressions by creating a matching pattern that connects all substrings from the array with vertical bars.

Basic Implementation

When certain that substrings don't contain regular expression special characters, use the following approach:

if (new RegExp(substrings.join("|")).test(str)) {
    // At least one matching substring exists
}

This method creates a regular expression containing all substrings. For example, if the substring array is ["one", "two"], it generates the regular expression /one|two/.

Special Character Handling

When substrings might contain regular expression special characters (such as *, +, ?, ., [, ], (, ), {, }, etc.), these characters must be escaped first. Use a dedicated escape function:

function escapeRegExp(string) {
    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

const escapedSubstrings = substrings.map(escapeRegExp);
if (new RegExp(escapedSubstrings.join("|")).test(str)) {
    // Handle matching cases
}

Performance Considerations

The regular expression method may offer performance advantages when dealing with large numbers of substrings or complex matching patterns, as regular expression engines are typically highly optimized. However, for simple substring checks, the some method is generally more straightforward and maintainable.

Method Comparison and Selection Guidelines

Both methods have their advantages and disadvantages. Consider the following factors when choosing:

Code Readability

The some method uses standard array operations, making code intentions clear and easy to understand and maintain. The regular expression approach may be less intuitive for developers unfamiliar with regex syntax.

Performance Characteristics

For small arrays and simple matching, performance differences between the two methods are minimal. However, as array size increases, regular expressions may perform better in some cases because they only need to compile the regex once.

Flexibility

The some method can be easily extended, such as adding additional matching conditions or complex matching logic. The regular expression method is more powerful for pattern matching but may be more complex to modify.

Recommended Usage Scenarios

• For most everyday applications, recommend using the some method with includes for its simplicity and good maintainability
• Consider the regular expression method when needing complex pattern matching or handling large numbers of substrings
• In performance-sensitive applications, conduct benchmark testing to select the optimal solution

Practical Application Extensions

In actual development, we often need to handle more complex string matching scenarios. For example, in document processing systems, we might need to check if document content contains specific business terminology.

Case-Insensitive Matching

If case-insensitive matching is required, both methods can be easily adapted:

Using the some method:

if (substrings.some(v => str.toLowerCase().includes(v.toLowerCase()))) {
    // Case-insensitive matching
}

Using regular expressions:

if (new RegExp(substrings.join("|"), "i").test(str)) {
    // Case-insensitive matching
}

Returning Specific Matching Substrings

Sometimes we need to know not just whether a match exists, but which specific substring matched:

function findMatchingSubstring(str, substrings) {
    return substrings.find(v => str.includes(v));
}

const matchingSubstring = findMatchingSubstring(str, substrings);
if (matchingSubstring) {
    console.log(`Found matching substring: ${matchingSubstring}`);
}

Best Practices Summary

Based on years of JavaScript development experience, here are some best practice recommendations:

Error Handling

In practical applications, appropriate error handling should be added:

function safeContainsCheck(str, substrings) {
    if (typeof str !== "string" || !Array.isArray(substrings)) {
        throw new Error("Invalid parameter types");
    }
    
    return substrings.some(v => {
        if (typeof v !== "string") return false;
        return str.includes(v);
    });
}

Performance Optimization

For frequently called scenarios, consider the following optimization strategies:

• Sort the substring array, placing the most likely matches first
• Use caching mechanisms to avoid repeated calculations
• For fixed substring arrays, pre-compile regular expressions

Testing Strategy

Comprehensive test cases should cover the following scenarios:

• Empty strings and empty arrays
• Exact matches and partial matches
• Special characters and edge cases
• Performance benchmark testing

Through the detailed analysis in this article, developers can choose the most suitable string matching method based on specific requirements and flexibly apply these techniques in practical applications.