Checking for Substrings in PHP

This article explores advanced techniques for checking substring presence, with emphasis on performance optimization and maintainability.

Core Strategies for Substring Detection

1. strpos() with Strict Type Checking

<?php
declare(strict_types=1);

/**
 * Checks if a string contains a substring with position validation
 * 
 * @param string $haystack The string to search
 * @param string $needle The substring to find
 * @return bool
 */
function containsSubstring(string $haystack, string $needle): bool {
    // Handle edge cases
    if ($needle === '') {
        return false;
    }
    
    $position = strpos($haystack, $needle);
    return $position !== false;
}

// Usage
$content = "Advanced PHP techniques for senior developers";
$searchTerm = "senior";

if (containsSubstring($content, $searchTerm)) {
    // Business logic here
}

Performance Note: This O(n) operation is memory efficient as it stops at first match.

2. Modern Approach with str_contains()

For PHP 8.0+ environments:

<?php
declare(strict_types=1);

/**
 * PHP 8.0+ optimized substring check
 * 
 * @throws InvalidArgumentException for empty needle
 */
function stringContains(string $haystack, string $needle): bool {
    if ($needle === '') {
        throw new InvalidArgumentException('Needle cannot be empty');
    }
    
    return str_contains($haystack, $needle);
}

Advantage: Explicit boolean return eliminates position comparison errors.

Advanced Pattern Matching

3. Regex with preg_match() for Complex Scenarios

<?php
declare(strict_types=1);

/**
 * Case-insensitive word boundary match
 * 
 * @param string $input The subject string
 * @param string $word The word to find (as whole word)
 * @return bool
 */
function containsWord(string $input, string $word): bool {
    $pattern = sprintf('/\b%s\b/iu', preg_quote($word, '/'));
    return (bool) preg_match($pattern, $input);
}

// Example: matches "PHP" but not "PHP5"
$text = "Modern PHP development";
$term = "PHP";

Best Practice: Always use preg_quote() to escape special characters.

Performance Optimization

Benchmark Results (1M iterations):

Recommendation: For high-throughput systems:

• Prefer str_contains() in PHP 8+
• Use strpos() for legacy systems
• Reserve regex for complex patterns

Edge Case Handling

Robust Implementation with Validation

<?php
declare(strict_types=1);

/**
 * Comprehensive substring checker with validation
 * 
 * @throws InvalidArgumentException
 */
function safeStringContains(string $haystack, string $needle, bool $caseSensitive = true): bool {
    if ($needle === '') {
        throw new InvalidArgumentException('Search term cannot be empty');
    }
    
    if (!$caseSensitive) {
        return stripos($haystack, $needle) !== false;
    }
    
    return strpos($haystack, $needle) !== false;
}

Framework Integration Patterns

Laravel Service Implementation

<?php
namespace App\Services;

use Illuminate\Support\Str;

class StringAnalyzer
{
    /**
     * Check for substring with framework conventions
     */
    public function hasSubstring(string $content, string $term, bool $wholeWord = false): bool
    {
        if ($wholeWord) {
            return Str::contains($content, $term);
        }
        
        return Str::contains(str_word_count($content, 1), $term);
    }
}

Security Considerations

1. Input Sanitization:

   $userInput = filter_input(INPUT_GET, 'search', FILTER_SANITIZE_STRING);
   $safeTerm = htmlspecialchars($userInput, ENT_QUOTES);
   

2. Regex Protection:

   function safePatternMatch(string $input, string $pattern): bool
   {
       set_error_handler(function() { throw new \Exception('Invalid regex'); });
       try {
           return preg_match($pattern, $input) === 1;
       } finally {
           restore_error_handler();
       }
   }
   

Conclusion

For senior-level PHP development:

1. PHP 8+ Projects: Use str_contains() for clarity and performance
2. Legacy Systems: Implement strict strpos() checks with helper functions
3. Complex Matching: Use regex with proper escaping and error handling
4. Frameworks: Leverage built-in helpers while maintaining validation

Final Recommendation: Create a utility class encapsulating these methods with proper type declarations and validation to ensure consistency across your codebase.

<?php
declare(strict_types=1);

namespace App\Utils;

final class StringChecker
{
    public static function contains(string $haystack, string $needle, bool $caseSensitive = true): bool
    {
        // Implementation with full validation
    }
    
    public static function containsWord(string $haystack, string $word): bool
    {
        // Whole word matching implementation
    }
    
    // Other methods...
}