How to use strpos to determine if a string exists in input string?

How to use strpos to determine if a string exists in input string?

  1. Blog
  2. 15 November 2026
  3. 3 min read

Stefan Bogdanescu

Founder & Senior Architect

The Truth Value Trap in PHP's strpos()

In the provided code snippet, the logic appears sound on the surface: you are attempting to verify that $filename contains the substring $match. However, the script exits early because strpos() returns a boolean false when the needle is not found, but it also returns an integer (starting from 0) when it is found.

The core issue lies in how PHP evaluates truthiness. When you use !strpos($filename, $match), you are relying on the fact that 0 is treated as falsey. If $match is found at the very beginning of the string, strpos() returns 0. The expression !0 evaluates to true, causing the condition inside your if block to trigger and execute die().

In your specific example, 'my_upgrade' is indeed a substring of 'my_upgrade(1).zip'. Consequently, strpos('my_upgrade(1).zip', 'my_upgrade') returns 0. Because 0 is considered falsey in PHP, the negation operator ! flips this to true, and your script dies immediately, which is the opposite of what you intended.

Checking Return Values Explicitly

To fix this, you must distinguish between "not found" (which strpos() returns as -1) and "found at index 0". The most robust approach is to check if the return value is strictly not equal to -1.

Instead of relying on truthiness checks, compare the result directly:

$filename = 'my_upgrade(1).zip';
$match = 'my_upgrade';

if (strpos($filename, $match) !== false) {
    // The string was found anywhere in the input
    proceed();
} else {
    die('String not found');
}

By using !== (strict comparison), you ensure that 0 is treated as a valid index rather than a failure state. This pattern is critical whenever searching for strings that might start at the beginning of the input. If you omit the strict operator or use ==, any match at the start of the string will incorrectly trigger your error handler.

Handling Case Sensitivity and Exact Matches

While fixing the boolean logic resolves the immediate crash, it is worth considering whether a simple substring search is the right tool for your use case. The strpos() function performs a case-sensitive search. If you need to ignore case, passing a third argument of true makes the comparison case-insensitive:

if (stripos($filename, $match) !== false) {
    proceed();
}

Using stripos() is often safer for filename validation because file systems and user inputs vary in casing conventions. However, this introduces a trade-off: if your application logic depends on exact case matching (e.g., distinguishing between FILE.zip and file.zip), strpos() remains the correct choice. Always weigh the need for case sensitivity against potential security implications or data integrity requirements.

Modern Alternatives in Laravel Ecosystems

If you are working within a Laravel application, consider whether native PHP functions are necessary at all. The framework provides utilities that can abstract away these edge cases. For instance, using Str::contains() offers a cleaner syntax and handles the return value logic internally:

use Illuminate\Support\Str;

if (Str::contains($filename, $match)) {
    proceed();
}

This method returns a boolean directly, removing the need to remember strict comparison operators for string positions. While strpos() offers low-level control and is available in every PHP environment without loading additional classes, Str::contains() improves readability and reduces the chance of logical errors like the one demonstrated above.

Summary of Best Practices

When validating substrings in PHP:

  1. Always use !== false to check strpos() results if there is a chance the substring starts at index 0.
  2. Use stripos() when case sensitivity is not a strict requirement.
  3. Prefer framework helpers like Str::contains() in Laravel projects for cleaner, less error-prone code.

Understanding how PHP treats integers as booleans prevents subtle bugs that can cause scripts to exit unexpectedly during development or production.

Our network