PHP String Containment Detection: Complete Guide from strpos to str_contains

Basic Concepts of String Containment Detection

In PHP development, detecting whether a string contains specific text is a common task. Developers often need to validate user input, parse data, or implement search functionality. Traditional PHP versions primarily rely on the strpos function, while modern PHP versions provide the more intuitive str_contains function.

In-depth Analysis of the strpos Function

The strpos function is used in PHP to find the position of a string, with the basic syntax strpos($haystack, $needle). This function returns the index of the first occurrence of $needle in $haystack, or false if not found.

The key point is understanding PHP's type conversion mechanism. Since 0 is treated as false in boolean contexts, and strpos may return 0 (when $needle appears at the beginning of the string), it is essential to use the strict comparison operator !==:

$haystack = "foo bar baz";
$needle = "bar";

if (strpos($haystack, $needle) !== false) {
    echo "\"bar\" exists in the haystack variable";
}

This approach ensures that the condition is only considered false when strpos actually returns false (indicating not found), avoiding the misinterpretation of position 0 as false.

The str_contains Function in PHP 8.0

PHP 8.0 introduced the str_contains function, specifically designed for string containment detection, with a more intuitive syntax:

if (str_contains('abc', '')) {
    echo "Checking the existence of the empty string will always return true";
}

This function directly returns a boolean value, eliminating concerns about type conversion and improving code readability. For new projects or environments upgraded to PHP 8.0+, this function is recommended.

Analysis of Practical Application Scenarios

In the user-provided example, the requirement is to detect whether variable $a contains 'some text':

$a = '';

if (strpos($a, 'some text') !== false) {
    echo 'text';
}

Or using str_contains:

if (str_contains($a, 'some text')) {
    echo 'text';
}

Extension to Word Boundary Detection

The scenario mentioned in the reference article illustrates more complex string matching requirements—detecting standalone words rather than substrings. This is particularly important in contexts such as chatbots and text analysis.

Although PHP does not have a built-in function for word boundary detection, it can be achieved using regular expressions:

$message = "My friend said hi.";

if (preg_match('/\bhi\b/i', $message)) {
    echo "Found standalone 'hi'";
}

The \b in the regular expression denotes a word boundary, ensuring that only the standalone "hi" is matched, and not the "hi" within "high" or "ship".

Performance and Compatibility Considerations

strpos is available in all PHP versions and offers high performance, but requires attention to type comparison details. str_contains has a simpler syntax but requires a PHP 8.0+ environment. Regular expressions are powerful and can handle complex patterns but are relatively slower in performance.

When choosing a solution, consider: the project's PHP version, performance requirements, and matching complexity. For simple substring detection, prefer str_contains (PHP 8.0+) or strpos (older versions); for complex matches like word boundaries, use regular expressions.

Summary of Best Practices

1. Clarify Requirements: Determine whether detecting substrings or standalone words is needed.

2. Version Compatibility: Choose the appropriate function based on the PHP version.

3. Strict Comparison: Always use !== false with strpos.

4. Error Handling: Consider empty strings and edge cases.

5. Performance Optimization: Avoid regular expressions for simple matches.

By appropriately selecting and using these string detection methods, developers can write robust and efficient PHP code that meets various string processing needs.