PHP字符串包含判断：从基础到高级，掌握多种高效方法314

```html

在PHP编程中，字符串处理无疑是最常见的操作之一。从用户输入验证到日志分析，从数据解析到内容搜索，判断一个字符串（我们称之为“干草堆”，haystack）中是否包含另一个特定的字符串（我们称之为“针”，needle）是一个核心且高频的需求。理解并熟练运用PHP提供的各种字符串查找函数，不仅能提升代码效率，更能确保程序的健壮性和可维护性。本文将深入探讨PHP中判断字符串包含关系的不同方法，包括它们的使用场景、性能特点、注意事项以及PHP 8+带来的新特性。

理解字符串包含判断的重要性

为什么字符串包含判断如此重要？想象一下以下场景：

表单验证：用户输入的用户名是否包含不允许的特殊字符？邮箱地址是否包含“@”符号？
URL路由：当前请求的URL是否包含特定的路径段，以触发相应的控制器或操作？
日志分析：在大量日志信息中，快速定位包含“ERROR”或“WARNING”关键词的条目。
文件处理：判断文件名是否以“.jpg”或“.png”结尾，以确定文件类型。
内容过滤：检查用户发布的内容是否包含敏感词汇。

这些都离不开字符串包含判断。PHP提供了多种函数来应对这些需求，每种函数都有其独特的特点和最佳适用场景。

方法一：使用 `strpos()` 或 `stripos()` 进行查找

`strpos()` 是PHP中最常用且性能优秀的字符串查找函数之一。它用于查找一个字符串在另一个字符串中首次出现的位置。

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

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

`$haystack`: 要搜索的字符串。
`$needle`: 要查找的子字符串。
`$offset`: 可选参数，指定从 `$haystack` 的哪个位置开始搜索。
返回值：如果找到 `$needle`，则返回其在 `$haystack` 中首次出现的起始位置（整数）；如果未找到，则返回 `false`。

关键注意事项：由于 `$needle` 可能出现在 `$haystack` 的开头（即位置 `0`），`0` 在PHP的弱类型比较中会被视为 `false`。因此，在判断 `strpos()` 的返回值时，务必使用严格比较运算符 `!== false` 或 `=== 0`。

<?php
$fullString = "Hello, world! This is a PHP example.";
$searchString1 = "world";
$searchString2 = "PHP";
$searchString3 = "php"; // 注意大小写
$searchString4 = "nonexistent";
// 示例 1: 找到子字符串
if (strpos($fullString, $searchString1) !== false) {
echo "'$fullString' 包含 '$searchString1'"; // 输出：'Hello, world! This is a PHP example.' 包含 'world'
} else {
echo "'$fullString' 不包含 '$searchString1'";
}
// 示例 2: 找到子字符串，位于开头
$startString = "Example string.";
if (strpos($startString, "Example") !== false) {
echo "'$startString' 包含 'Example' (位置为 0)"; // 输出：'Example string.' 包含 'Example' (位置为 0)
}
// 示例 3: 未找到子字符串（区分大小写）
if (strpos($fullString, $searchString3) !== false) {
echo "'$fullString' 包含 '$searchString3'";
} else {
echo "'$fullString' 不包含 '$searchString3' (因为大小写不匹配)"; // 输出：'Hello, world! This is a PHP example.' 不包含 'php' (因为大小写不匹配)
}
// 示例 4: 明确未找到
if (strpos($fullString, $searchString4) !== false) {
echo "'$fullString' 包含 '$searchString4'";
} else {
echo "'$fullString' 不包含 '$searchString4'"; // 输出：'Hello, world! This is a PHP example.' 不包含 'nonexistent'
}
// 示例 5: 指定偏移量
$text = "apple, banana, apple pie";
if (strpos($text, "apple", 1) !== false) { // 从位置1开始搜索，会找到第二个"apple"
echo "从位置1开始，'$text' 包含 'apple'"; // 输出：从位置1开始，'apple, banana, apple pie' 包含 'apple'
}
?>

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

`stripos()` 的功能与 `strpos()` 完全相同，唯一的区别是它在查找时会忽略大小写。

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

<?php
$fullString = "Hello, world! This is a PHP example.";
$searchString = "php"; // 小写
if (stripos($fullString, $searchString) !== false) {
echo "'$fullString' 包含 '$searchString' (不区分大小写)"; // 输出：'Hello, world! This is a PHP example.' 包含 'php' (不区分大小写)
} else {
echo "'$fullString' 不包含 '$searchString' (不区分大小写)";
}
?>

多字节字符：对于包含中文、日文等UTF-8字符的字符串，`strpos()` 和 `stripos()` 可能会出现意外结果，因为它们是基于字节而不是字符工作的。在这种情况下，应使用多字节字符串函数，如 `mb_strpos()` 和 `mb_stripos()`。使用前通常需要确保 `mbstring` 扩展已启用。

<?php
$multiByteString = "你好，世界！这是一个PHP示例。";
$searchMultiByte = "世界";
if (function_exists('mb_strpos')) {
if (mb_strpos($multiByteString, $searchMultiByte, 0, 'UTF-8') !== false) {
echo "'$multiByteString' 包含 '$searchMultiByte' (使用mb_strpos)";
} else {
echo "'$multiByteString' 不包含 '$searchMultiByte' (使用mb_strpos)";
}
} else {
echo "mbstring 扩展未启用，无法使用 mb_strpos。";
}
?>

方法二：使用 `strstr()` 或 `stristr()` 查找并获取子字符串

`strstr()` 函数不仅能判断子字符串是否存在，还能返回从子字符串第一次出现位置开始到原始字符串结尾的部分。如果只需要判断是否存在，`strpos()` 更为高效；但如果后续还需要用到匹配到的部分，`strstr()` 则更为方便。

`strstr()`：区分大小写的查找并返回子字符串

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

`$haystack`: 要搜索的字符串。
`$needle`: 要查找的子字符串。
`$before_needle`: 可选参数，如果设置为 `true`，则返回 `$needle` 之前的部分；默认为 `false`，返回 `$needle` 及其之后的部分。
返回值：如果找到 `$needle`，则返回从 `$needle` 首次出现位置开始到 `$haystack` 结尾的子字符串（或者根据 `$before_needle` 返回之前的部分）；如果未找到，则返回 `false`。

<?php
$email = "user@";
$domain = strstr($email, "@"); // $domain 将是 "@"
$username = strstr($email, "@", true); // $username 将是 "user"
if ($domain !== false) {
echo "邮箱地址 '$email' 包含 '@' 符号。域名部分: '$domain'"; // 输出：邮箱地址 'user@' 包含 '@' 符号。域名部分: '@'
}
if ($username !== false) {
echo "用户名部分: '$username'"; // 输出：用户名部分: 'user'
}
if (strstr("No-at-sign", "@") === false) {
echo "'No-at-sign' 不包含 '@' 符号。";
}
?>

`stristr()`：不区分大小写的查找并返回子字符串

`stristr()` 的功能与 `strstr()` 相同，但它在查找时会忽略大小写。

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

<?php
$message = "Welcome To Our Site!";
$search = "site"; // 小写
$result = stristr($message, $search); // $result 将是 "Site!"
if ($result !== false) {
echo "'$message' 包含 '$search' (不区分大小写)。匹配结果: '$result'"; // 输出：'Welcome To Our Site!' 包含 'site' (不区分大小写)。匹配结果: 'Site!'
}
?>

同样，对于多字节字符串，应使用 `mb_strstr()` 和 `mb_stristr()`。

方法三：PHP 8+ 新特性 `str_contains()`

PHP 8.0 引入了一个专门用于判断字符串是否包含子字符串的函数 `str_contains()`。它的设计目标是提高代码的可读性和直观性，直接返回布尔值。

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

`$haystack`: 要搜索的字符串。
`$needle`: 要查找的子字符串。
返回值：如果 `$haystack` 包含 `$needle`，则返回 `true`；否则返回 `false`。

<?php
if (version_compare(PHP_VERSION, '8.0.0') >= 0) { // 检查PHP版本是否支持
$text = "PHP 8 makes string operations easier.";
$sub1 = "string";
$sub2 = "easy"; // 注意大小写
$sub3 = "Python";
// 示例 1: 包含子字符串
if (str_contains($text, $sub1)) {
echo "'$text' 包含 '$sub1'."; // 输出：'PHP 8 makes string operations easier.' 包含 'string'.
}
// 示例 2: 不包含（区分大小写）
if (!str_contains($text, $sub2)) {
echo "'$text' 不包含 '$sub2' (因为是区分大小写的)."; // 输出：'PHP 8 makes string operations easier.' 不包含 'easy' (因为是区分大小写的).
}
// 示例 3: 完全不包含
if (!str_contains($text, $sub3)) {
echo "'$text' 不包含 '$sub3'."; // 输出：'PHP 8 makes string operations easier.' 不包含 'Python'.
}
// 模拟不区分大小写的 str_contains (如果需要)
// 可以通过将两个字符串都转换为小写来实现，但这会带来额外开销
if (str_contains(strtolower($text), strtolower("Easy"))) {
echo "'$text' 包含 'Easy' (通过转换为小写实现不区分大小写).";
}
} else {
echo "当前PHP版本低于8.0，不支持 str_contains()。请使用 strpos() 代替。";
}
?>

`str_contains()` 的主要优点是其简洁性和明确性。它直接回答了“是否包含”这个问题，避免了 `strpos() !== false` 这种稍微冗长的写法，并消除了因 `0` 被误判为 `false` 的潜在风险。然而，它不提供不区分大小写的功能，也不支持多字节字符串（`mb_str_contains()` 目前不存在，需要自行实现或结合 `mb_strpos()`）。

方法四：使用 `preg_match()` 进行正则表达式匹配

当查找的模式变得复杂，需要匹配更灵活的规则时，正则表达式（Regular Expressions）是你的强大工具。PHP通过 `preg_match()` 函数支持正则表达式。

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

`$pattern`: 要搜索的正则表达式模式。
`$subject`: 要搜索的字符串。
`$matches`: 可选参数，用于存储匹配结果。
返回值：如果匹配成功，返回 `1`；如果未匹配到，返回 `0`；如果发生错误，返回 `false`。

<?php
$logEntry = "2023-10-27 10:30:05 [ERROR] User 'admin' failed login from 192.168.1.100.";
// 示例 1: 查找简单的子字符串（区分大小写）
if (preg_match("/ERROR/", $logEntry)) {
echo "日志条目包含 'ERROR'."; // 输出：日志条目包含 'ERROR'.
}
// 示例 2: 查找不区分大小写的子字符串 (使用i修饰符)
if (preg_match("/warning/i", $logEntry)) {
echo "日志条目包含 'warning' (不区分大小写).";
} else {
echo "日志条目不包含 'warning' (不区分大小写)."; // 输出：日志条目不包含 'warning' (不区分大小写).
}
// 示例 3: 查找更复杂的模式 (例如IP地址)
if (preg_match("/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/", $logEntry, $matches)) {
echo "日志条目包含IP地址: " . $matches[0] . ""; // 输出：日志条目包含IP地址: 192.168.1.100
}
// 示例 4: 查找多个关键词中的任意一个
if (preg_match("/(ERROR|WARNING|FATAL)/", $logEntry)) {
echo "日志条目包含 'ERROR', 'WARNING' 或 'FATAL' 中的任意一个."; // 输出：日志条目包含 'ERROR', 'WARNING' 或 'FATAL' 中的任意一个.
}
?>

优点：极其灵活，可以处理几乎所有复杂的字符串模式匹配需求。

缺点：相对于 `strpos()` 或 `str_contains()`，正则表达式的性能开销通常更大，对于简单的子字符串查找而言，效率较低。语法相对复杂，可读性可能不如直接函数。

何时使用：当需要匹配的模式不仅是一个固定的子字符串，而是具有一定规律或结构（如邮箱格式、日期、URL、多个关键词中的任意一个等）时，`preg_match()` 是最佳选择。

方法五：使用 `substr_count()` 统计子字符串出现次数

`substr_count()` 函数用于计算子字符串在主字符串中出现的次数。虽然它的主要目的是计数，但如果返回的次数大于 0，则意味着子字符串存在。

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

`$haystack`: 要搜索的字符串。
`$needle`: 要查找的子字符串。
`$offset`: 可选参数，指定从 `$haystack` 的哪个位置开始搜索。
`$length`: 可选参数，指定在 `$haystack` 中搜索的长度。
返回值： `$needle` 在 `$haystack` 中出现的次数（整数）。

<?php
$sentence = "The quick brown fox jumps over the lazy dog. The quick brown fox.";
$word = "quick";
$nonExistentWord = "cat";
$count = substr_count($sentence, $word);
if ($count > 0) {
echo "'$sentence' 包含 '$word'，出现了 $count 次。"; // 输出：'The quick brown fox jumps over the lazy dog. The quick brown fox.' 包含 'quick'，出现了 2 次。
} else {
echo "'$sentence' 不包含 '$word'.";
}
if (substr_count($sentence, $nonExistentWord) > 0) {
echo "'$sentence' 包含 '$nonExistentWord'.";
} else {
echo "'$sentence' 不包含 '$nonExistentWord'."; // 输出：'The quick brown fox jumps over the lazy dog. The quick brown fox.' 不包含 'cat'.
}
?>

优点：除了判断是否存在，还能直接获取出现次数，适用于需要同时获取这两个信息的场景。

缺点：性能略低于 `strpos()`，因为它需要遍历整个字符串并计数。对于纯粹的“是否存在”判断，不是最推荐的方法。不支持不区分大小写（需要先将字符串转换为小写或大写），不支持多字节字符（需要 `mb_substr_count()`）。

性能考量与最佳实践

在选择字符串查找方法时，性能和可读性是两个重要的考量因素：

最快的选择 (`str_contains()` / `strpos()`)：对于简单的、固定的子字符串查找，`str_contains()` (PHP 8+) 是最清晰、最推荐的选择。如果你的PHP版本低于8.0，`strpos() !== false` 是最佳实践，并且性能非常高。
不区分大小写 (`stripos()` / `stristr()`)：当不关心大小写时，使用 `stripos()` 或 `stristr()`。它们比先转换大小写再使用 `strpos()` 更高效。
多字节字符 (`mb_strpos()` / `mb_stripos()` 等)：处理包含中文等字符的字符串时，务必使用 `mb_*` 系列函数，以避免乱码和不准确的结果。
复杂模式 (`preg_match()`)：只有当模式无法用简单字符串函数表达时，才考虑使用正则表达式。其性能开销较大，不应滥用于简单的查找。
获取匹配内容 (`strstr()` / `stristr()` / `preg_match()`)：如果除了判断存在性外，还需要获取匹配到的子字符串或其周围内容，那么 `strstr()` 或 `preg_match()` 会是更好的选择。
统计次数 (`substr_count()`)：如果你需要知道子字符串出现的具体次数，那么 `substr_count()` 是最直接的方法。如果只是判断是否存在，则不如 `strpos()` 高效。

总结最佳实践：

优先使用 `str_contains()` (PHP 8+)。
如果PHP版本低于8.0，优先使用 `strpos() !== false`。
需要不区分大小写时，使用 `stripos() !== false`。
处理多字节字符串时，务必使用 `mb_*` 系列函数。
只在真正需要复杂模式匹配时才使用 `preg_match()`。
避免过度优化：通常情况下，上述函数的性能差异在大多数应用中是微不足道的，选择最能清晰表达意图的函数更重要。

高级应用场景示例

1. 检查字符串是否包含列表中的任意一个关键词

<?php
$article = "PHP is a popular scripting language. It's great for web development.";
$keywords = ["JavaScript", "Python", "PHP", "Laravel"];
$foundKeyword = false;
// 方法一：使用 foreach 循环和 str_contains (PHP 8+)
if (version_compare(PHP_VERSION, '8.0.0') >= 0) {
foreach ($keywords as $keyword) {
if (str_contains($article, $keyword)) {
$foundKeyword = true;
echo "文章包含关键词: '$keyword'";
break;
}
}
} else {
// 方法二：使用 foreach 循环和 strpos (PHP < 8.0)
foreach ($keywords as $keyword) {
if (strpos($article, $keyword) !== false) {
$foundKeyword = true;
echo "文章包含关键词: '$keyword'";
break;
}
}
}
if (!$foundKeyword) {
echo "文章不包含任何指定关键词。";
}
// 方法三：使用正则表达式 (更简洁，但性能略低)
$pattern = "/" . implode("|", array_map('preg_quote', $keywords)) . "/i"; // i表示不区分大小写
if (preg_match($pattern, $article)) {
echo "文章包含列表中的任意一个关键词 (通过正则)。";
}
?>

2. 验证文件上传类型

<?php
$fileName = "";
$allowedExtensions = ['.pdf', '.doc', '.docx', '.xlsx'];
$isValidExtension = false;
foreach ($allowedExtensions as $ext) {
if (str_ends_with($fileName, $ext)) { // PHP 8+ str_ends_with 更高效
$isValidExtension = true;
break;
}
// PHP < 8.0 可以使用 substr 结合 strlen
// if (substr($fileName, -strlen($ext)) === $ext) {
// $isValidExtension = true;
// break;
// }
}
if ($isValidExtension) {
echo "文件 '$fileName' 具有有效扩展名。"; // 输出：文件 '' 具有有效扩展名。
} else {
echo "文件 '$fileName' 具有无效扩展名。";
}
?>

（注：PHP 8+ 还提供了 `str_starts_with()` 和 `str_ends_with()` 函数，专门用于判断字符串是否以某个子字符串开始或结束，这在某些场景下比 `str_contains()` 更具描述性且可能更高效。）

结语

PHP提供了丰富的函数来处理字符串包含判断的需求。从基础的 `strpos()` 到现代的 `str_contains()`，再到强大的 `preg_match()`，每种方法都有其独特的价值。作为专业的程序员，我们应该根据具体的场景、性能要求、PHP版本兼容性以及代码的可读性，明智地选择最适合的工具。熟练掌握这些函数，将大大提升你在PHP项目中的字符串处理能力，编写出更高效、更健壮的代码。
```

2025-10-12

上一篇：PHP字符串转字符串数组：从入门到精通

下一篇：PHP多维数组相加：深度解析与实战技巧