PHP字符串查找技术：从基本函数到正则表达式的深度剖析282

```html

在PHP编程中，判断一个字符串是否包含另一个特定的子字符串是一个极其常见的任务。无论是进行数据验证、URL路由、日志分析、文本搜索还是内容过滤，这项功能都无处不在。PHP提供了多种内置函数和机制来完成这项任务，它们各有特点，适用于不同的场景。作为一名专业的程序员，理解这些方法的原理、性能差异以及最佳实践至关重要。本文将深入探讨PHP中检测字符串包含关系的所有主流方法，从最基础的字符串函数到强大的正则表达式，并提供详尽的代码示例和使用建议。

一、最常用且高效的方法：`strpos()` 和 `stripos()`

`strpos()` 函数是PHP中查找子字符串位置最常用且效率最高的方法之一。它返回子字符串在父字符串中第一次出现的位置（索引），如果未找到则返回 `false`。由于子字符串可能出现在父字符串的开头（索引为0），因此在使用 `strpos()` 进行判断时，务必使用严格的非相等比较运算符 `!== false`。

函数签名：

`strpos(string $haystack, string $needle, int $offset = 0): int|false`

参数说明：
`$haystack`：在其中搜索的字符串（大海）。
`$needle`：要搜索的子字符串（针）。
`$offset`：可选参数，指定从 `$haystack` 的哪个位置开始搜索。

返回值：

如果找到 `$needle`，返回其在 `$haystack` 中第一次出现的位置（从0开始）。如果未找到，返回 `false`。

1.1 `strpos()`：区分大小写查找

<?php
$fullString = "Hello, world! This is a PHP string example.";
$searchString1 = "world";
$searchString2 = "PHP";
$searchString3 = "php"; // 注意大小写
// 示例 1: 查找成功
if (strpos($fullString, $searchString1) !== false) {
echo "'{$fullString}' 包含 '{$searchString1}' (区分大小写). "; // 输出: 'Hello, world! This is a PHP string example.' 包含 'world' (区分大小写).
} else {
echo "'{$fullString}' 不包含 '{$searchString1}' (区分大小写). ";
}
// 示例 2: 查找成功 (起始位置为0的情况)
$startString = "PHP is great!";
if (strpos($startString, "PHP") !== false) {
echo "'{$startString}' 包含 'PHP' (区分大小写). "; // 输出: 'PHP is great!' 包含 'PHP' (区分大小写).
}
// 示例 3: 查找失败 (大小写不匹配)
if (strpos($fullString, $searchString3) !== false) {
echo "'{$fullString}' 包含 '{$searchString3}' (区分大小写). ";
} else {
echo "'{$fullString}' 不包含 '{$searchString3}' (区分大小写). "; // 输出: 'Hello, world! This is a PHP string example.' 不包含 'php' (区分大小写).
}
?>

1.2 `stripos()`：不区分大小写查找

`stripos()` 函数的功能与 `strpos()` 相同，但它在搜索时不区分大小写。这在用户输入搜索或处理不确定大小写的数据时非常有用。

函数签名：

`stripos(string $haystack, string $needle, int $offset = 0): int|false`<?php
$fullString = "Hello, world! This is a PHP string example.";
$searchString1 = "php"; // 小写
$searchString2 = "EXAMPLE"; // 大写
// 示例 1: 查找成功 (不区分大小写)
if (stripos($fullString, $searchString1) !== false) {
echo "'{$fullString}' 包含 '{$searchString1}' (不区分大小写). "; // 输出: 'Hello, world! This is a PHP string example.' 包含 'php' (不区分大小写).
} else {
echo "'{$fullString}' 不包含 '{$searchString1}' (不区分大小写). ";
}
// 示例 2: 查找成功 (不区分大小写)
if (stripos($fullString, $searchString2) !== false) {
echo "'{$fullString}' 包含 '{$searchString2}' (不区分大小写). "; // 输出: 'Hello, world! This is a PHP string example.' 包含 'EXAMPLE' (不区分大小写).
} else {
echo "'{$fullString}' 不包含 '{$searchString2}' (不区分大小写). ";
}
?>

二、获取子字符串的其余部分：`strstr()` 和 `stristr()`

`strstr()` 函数用于查找子字符串的第一次出现，并返回从该位置到字符串结尾的子字符串。如果未找到子字符串，则返回 `false`。虽然它的主要目的是提取，但也可以用于判断字符串是否包含某个子字符串。

函数签名：

`strstr(string $haystack, string $needle, bool $before_needle = false): string|false`

参数说明：
`$haystack`：在其中搜索的字符串。
`$needle`：要搜索的子字符串。
`$before_needle`：可选参数。如果设置为 `true`，`strstr()` 将返回 `$needle` 第一次出现之前的字符串部分。

2.1 `strstr()`：区分大小写查找与提取

<?php
$email = "user@";
$domain = strstr($email, '@'); // 返回 "@"
$username = strstr($email, '@', true); // 返回 "user"
if ($domain !== false) {
echo "'{$email}' 包含 '@'，其后的部分是: {$domain} "; // 输出: 'user@' 包含 '@'，其后的部分是: @
}
if ($username !== false) {
echo "'{$email}' 包含 '@'，其之前的部分是: {$username} "; // 输出: 'user@' 包含 '@'，其之前的部分是: user
}
// 用作包含判断
if (strstr($email, 'example') !== false) {
echo "'{$email}' 包含 'example' (区分大小写). "; // 输出: 'user@' 包含 'example' (区分大小写).
}
// 查找失败
if (strstr($email, 'PHP') === false) {
echo "'{$email}' 不包含 'PHP' (区分大小写). "; // 输出: 'user@' 不包含 'PHP' (区分大小写).
}
?>

2.2 `stristr()`：不区分大小写查找与提取

`stristr()` 是 `strstr()` 的不区分大小写版本。

函数签名：

`stristr(string $haystack, string $needle, bool $before_needle = false): string|false`<?php
$url = "/";
if (stristr($url, 'example') !== false) {
echo "'{$url}' 包含 'example' (不区分大小写). "; // 输出: '/' 包含 'example' (不区分大小写).
}
$protocol = stristr($url, '://', true); // 获取协议部分
if ($protocol !== false) {
echo "协议是: {$protocol} "; // 输出: 协议是: http
}
?>

三、统计子字符串出现次数：`substr_count()`

`substr_count()` 函数用于计算子字符串在父字符串中出现的次数。如果子字符串没有出现，它将返回0。这使得它成为一个非常直观的判断字符串是否包含另一个字符串的方法：只要返回值大于0，就说明包含。

函数签名：

`substr_count(string $haystack, string $needle, int $offset = 0, ?int $length = null): int`

参数说明：
`$haystack`：在其中搜索的字符串。
`$needle`：要搜索的子字符串。
`$offset`：可选参数，指定从 `$haystack` 的哪个位置开始搜索。
`$length`：可选参数，指定搜索的长度。

返回值：

子字符串出现的次数。如果未找到，返回0。<?php
$text = "apple banana apple orange apple";
$search1 = "apple";
$search2 = "grape";
$search3 = "Apple"; // 注意大小写
// 示例 1: 查找成功 (出现多次)
$count1 = substr_count($text, $search1);
if ($count1 > 0) {
echo "'{$text}' 包含 '{$search1}'，出现 {$count1} 次. "; // 输出: 'apple banana apple orange apple' 包含 'apple'，出现 3 次.
}
// 示例 2: 查找失败 (未出现)
$count2 = substr_count($text, $search2);
if ($count2 > 0) {
echo "'{$text}' 包含 '{$search2}'，出现 {$count2} 次. ";
} else {
echo "'{$text}' 不包含 '{$search2}'. "; // 输出: 'apple banana apple orange apple' 不包含 'grape'.
}
// 示例 3: 查找失败 (区分大小写)
$count3 = substr_count($text, $search3);
if ($count3 > 0) {
echo "'{$text}' 包含 '{$search3}'，出现 {$count3} 次. ";
} else {
echo "'{$text}' 不包含 '{$search3}' (区分大小写). "; // 输出: 'apple banana apple orange apple' 不包含 'Apple' (区分大小写).
}
// 结合 strtolower() 实现不区分大小写查找
$lowerText = strtolower($text);
$lowerSearch3 = strtolower($search3);
$count4 = substr_count($lowerText, $lowerSearch3);
if ($count4 > 0) {
echo "'{$text}' 包含 '{$search3}' (不区分大小写)，出现 {$count4} 次. "; // 输出: 'apple banana apple orange apple' 包含 'Apple' (不区分大小写)，出现 3 次.
}
?>

注意： `substr_count()` 无法直接进行不区分大小写的搜索，需要结合 `strtolower()` 或 `strtoupper()` 先将字符串转换为统一大小写。

四、强大的模式匹配：`preg_match()` (正则表达式)

当需要进行更复杂的模式匹配，而不仅仅是简单的子字符串查找时，正则表达式是首选工具。PHP提供了 `preg_match()` 函数，它使用Perl兼容正则表达式（PCRE）语法来搜索匹配。

函数签名：

`preg_match(string $pattern, string $subject, array &$matches = null, int $flags = 0, int $offset = 0): int|false`

参数说明：
`$pattern`：要搜索的正则表达式模式。模式需要用定界符（如 `/`、`#`、`~`）包围。
`$subject`：在其中搜索的字符串。
`$matches`：可选参数，如果提供了，该数组将包含所有匹配结果。
`$flags`：可选参数，用于指定匹配行为。
`$offset`：可选参数，指定从 `$subject` 的哪个位置开始搜索。

返回值：

如果找到匹配项，返回1。如果未找到匹配项，返回0。如果发生错误，返回 `false`。

4.1 基本的正则表达式查找

<?php
$logEntry = "[INFO] User 'admin' logged in from 192.168.1.100.";
// 示例 1: 查找一个简单子字符串 (区分大小写)
if (preg_match('/admin/', $logEntry)) {
echo "'{$logEntry}' 包含 'admin'. "; // 输出: '[INFO] User 'admin' logged in from 192.168.1.100.' 包含 'admin'.
}
// 示例 2: 不区分大小写查找 (使用修饰符 'i')
if (preg_match('/user/i', $logEntry)) {
echo "'{$logEntry}' 包含 'user' (不区分大小写). "; // 输出: '[INFO] User 'admin' logged in from 192.168.1.100.' 包含 'user' (不区分大小写).
}
// 示例 3: 查找带有特定前缀的单词
if (preg_match('/\bUser\b/', $logEntry)) { // \b 表示单词边界
echo "'{$logEntry}' 包含单词 'User'. "; // 输出: '[INFO] User 'admin' logged in from 192.168.1.100.' 包含单词 'User'.
}
// 示例 4: 查找IP地址模式
if (preg_match('/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/', $logEntry, $matches)) {
echo "'{$logEntry}' 包含IP地址: {$matches[0]}. "; // 输出: '[INFO] User 'admin' logged in from 192.168.1.100.' 包含IP地址: 192.168.1.100.
} else {
echo "'{$logEntry}' 不包含IP地址. ";
}
?>

注意： 正则表达式虽然强大，但通常比简单的字符串函数执行速度慢。对于简单的子字符串查找，应优先使用 `strpos()` 或 `str_contains()`。

五、PHP 8+ 的现代方法：`str_contains()`

从PHP 8.0 开始，PHP引入了一个新的函数 `str_contains()`，专门用于判断一个字符串是否包含另一个子字符串。这是目前最推荐的方式，因为它语义清晰，直接返回布尔值 `true` 或 `false`，避免了 `strpos()` 中 `0` 和 `false` 的混淆问题。

函数签名：

`str_contains(string $haystack, string $needle): bool`

参数说明：
`$haystack`：在其中搜索的字符串。
`$needle`：要搜索的子字符串。

返回值：

如果 `$haystack` 包含 `$needle`，返回 `true`。否则返回 `false`。<?php
$sentence = "The quick brown fox jumps over the lazy dog.";
$word1 = "fox";
$word2 = "cat";
$word3 = "quick";
// 示例 1: 查找成功
if (str_contains($sentence, $word1)) {
echo "'{$sentence}' 包含 '{$word1}'. "; // 输出: 'The quick brown fox jumps over the lazy dog.' 包含 'fox'.
}
// 示例 2: 查找失败
if (str_contains($sentence, $word2)) {
echo "'{$sentence}' 包含 '{$word2}'. ";
} else {
echo "'{$sentence}' 不包含 '{$word2}'. "; // 输出: 'The quick brown fox jumps over the lazy dog.' 不包含 'cat'.
}
// 示例 3: 查找开头
if (str_contains($sentence, $word3)) {
echo "'{$sentence}' 包含 '{$word3}'. "; // 输出: 'The quick brown fox jumps over the lazy dog.' 包含 'quick'.
}
// PHP 8.0+ 提供了 str_starts_with() 和 str_ends_with() 来判断字符串是否以某个子串开始或结束
if (str_starts_with($sentence, "The")) {
echo "'{$sentence}' 以 'The' 开始. "; // 输出: 'The quick brown fox jumps over the lazy dog.' 以 'The' 开始.
}
if (str_ends_with($sentence, "dog.")) {
echo "'{$sentence}' 以 'dog.' 结束. "; // 输出: 'The quick brown fox jumps over the lazy dog.' 以 'dog.' 结束.
}
?>

注意： `str_contains()` 区分大小写。目前PHP标准库中还没有内置的 `str_icontains()` 函数。如果需要不区分大小写，你可以将两个字符串都转换为小写（或大写）再进行比较，或者使用 `stripos()` / `preg_match('/pattern/i')`。

六、自定义函数（Polyfill或Helper）

如果你的项目运行在PHP 7.x 或更早的版本，无法使用 `str_contains()`，但又想拥有其语义上的便利，可以创建一个自定义函数作为 Polyfill 或 helper。<?php
// str_contains() 的 Polyfill
if (!function_exists('str_contains')) {
function str_contains(string $haystack, string $needle): bool
{
return $needle === '' || strpos($haystack, $needle) !== false;
}
}
// 不区分大小写的 str_icontains() helper
if (!function_exists('str_icontains')) {
function str_icontains(string $haystack, string $needle): bool
{
return $needle === '' || stripos($haystack, $needle) !== false;
}
}
$testString = "Hello PHP World";
echo "str_contains('{$testString}', 'PHP'): " . (str_contains($testString, 'PHP') ? 'True' : 'False') . " "; // True
echo "str_contains('{$testString}', 'php'): " . (str_contains($testString, 'php') ? 'True' : 'False') . " "; // False
echo "str_icontains('{$testString}', 'PHP'): " . (str_icontains($testString, 'PHP') ? 'True' : 'False') . " "; // True
echo "str_icontains('{$testString}', 'php'): " . (str_icontains($testString, 'php') ? 'True' : 'False') . " "; // True
?>

七、性能考量与选择建议

在大多数情况下，性能差异对于短字符串和低频操作来说可以忽略不计。但对于处理大量文本或在性能敏感的应用中，选择正确的方法很重要：
`str_contains()` (PHP 8+)：最佳选择。语义最清晰，通常在底层实现上也很高效。优先使用。
`strpos()` / `stripos()`：对于PHP 8.0 以下版本，这是最快和最推荐的简单子字符串查找方法。它们是C语言级别实现的，非常高效。务必使用 `!== false` 进行严格判断。
`substr_count()`：如果除了判断是否存在，还需要知道子字符串出现的次数，那么这是一个不错的选择。但在仅判断是否存在时，它可能略慢于 `strpos()`，因为它需要遍历整个字符串来计数。
`strstr()` / `stristr()`：当你的主要目的是提取子字符串及其之后（或之前）的部分时，它们非常有用。如果只是判断是否存在，`strpos()` 更直接。
`preg_match()`：功能最强大但通常最慢。只在需要进行复杂的模式匹配（如正则表达式、通配符、多条件匹配等）时使用。对于简单的子字符串查找，其性能开销通常不值得。正则表达式引擎需要更多的处理时间和资源。

总结选择策略：

PHP 8.0 及更高版本： 优先使用 `str_contains()` 进行区分大小写的判断。如果需要不区分大小写，可以考虑 `stripos()` 或将字符串转换为统一大小写后使用 `str_contains()`。
PHP 7.x 及更早版本： 使用 `strpos($haystack, $needle) !== false` 进行区分大小写的判断。使用 `stripos($haystack, $needle) !== false` 进行不区分大小写的判断。
需要统计次数： 使用 `substr_count()`。
需要复杂模式匹配或灵活的条件： 使用 `preg_match()`。

八、常见陷阱与最佳实践
`strpos()` 的 `0` 和 `false`：
这是PHP初学者最常犯的错误。`strpos()` 在子字符串位于开头时返回 `0`，而未找到时返回 `false`。由于在PHP中 `0` 和 `false` 在非严格比较 (`==`) 下被认为是相等的，所以 `if (strpos($string, $search))` 可能会在子字符串位于开头时错误地判断为未找到。
最佳实践： 始终使用严格的比较运算符 `!== false` 或 `=== false`。
<?php
$str = "hello world";
// 错误示范：
if (strpos($str, "hello")) { // 'hello' 位于索引 0，0 被认为是 false，导致条件不成立
echo "错误: 'hello' 被找到. ";
} else {
echo "错误: 'hello' 未被找到. "; // 将输出此行
}
// 正确示范：
if (strpos($str, "hello") !== false) {
echo "正确: 'hello' 被找到. "; // 将输出此行
}
?>

字符编码问题：
对于包含多字节字符（如中文、日文、韩文等）的字符串，`strpos()`、`stripos()` 等函数可能会产生错误的结果，因为它们是按字节而非字符进行操作。
最佳实践： 对于多字节字符串，应使用 `mb_strpos()`、`mb_stripos()` 等 `mb_*` 函数系列。
<?php
$mbString = "你好世界，PHP编程";
$mbSearch = "世界";
// mb_strpos() 用于多字节字符串
if (mb_strpos($mbString, $mbSearch, 0, 'UTF-8') !== false) {
echo "'{$mbString}' 包含 '{$mbSearch}' (多字节). ";
} else {
echo "'{$mbString}' 不包含 '{$mbSearch}' (多字节). ";
}
?>

正则表达式性能与安全：
正则表达式虽然强大，但也可能带来性能问题（尤其是复杂或写得不好的模式）和安全风险（ReDoS攻击）。
最佳实践：

对于简单查找，避免使用正则表达式。
确保正则表达式模式是优化的，避免过多的回溯。
如果模式来自用户输入，务必使用 `preg_quote()` 来转义特殊字符，以防止注入攻击。

<?php
$userInput = ".?"; // 用户可能输入包含特殊字符的搜索词
$safePattern = '/' . preg_quote($userInput, '/') . '/';
$text = "Is this. a test?";
if (preg_match($safePattern, $text)) {
echo "安全查找: '{$text}' 包含 '{$userInput}'. ";
} else {
echo "安全查找: '{$text}' 不包含 '{$userInput}'. ";
}
?>

结语

PHP提供了丰富而强大的字符串处理函数，用于判断一个字符串是否包含另一个字符串。从简单高效的 `strpos()` 和 `str_contains()`，到用于计数和更复杂模式匹配的 `substr_count()` 和 `preg_match()`，每种方法都有其独特的应用场景和优缺点。作为一名专业的PHP开发者，你应该根据具体的业务需求、PHP版本以及性能考量，明智地选择最适合的工具，并遵循最佳实践，以编写出健壮、高效且易于维护的代码。理解这些函数的细微差别，将显著提升你在字符串处理方面的能力。```

2025-11-06

上一篇：PHP数组存储与显示图片：从基础到高级实践

下一篇：PHP文件管理：深度解析主流框架与最佳实践，构建高效安全的Web应用