PHP中判断字符串是否包含子字符串：全面指南与最佳实践341

作为一名专业的程序员，在日常开发中，我们经常需要处理字符串。其中一个非常常见的任务就是判断一个字符串是否包含另一个子字符串。这在数据验证、文本搜索、URL路由、日志分析等多种场景下都至关重要。PHP作为一门强大的Web开发语言，提供了多种灵活且高效的方法来完成这项任务。本文将深入探讨PHP中判断子字符串存在性的各种技术、它们的使用场景、性能考量以及最佳实践，旨在为开发者提供一个全面的指南。

字符串操作是编程中最基础也是最频繁的任务之一。在PHP的世界里，无论你是处理用户输入、解析文件内容、构建URL，还是进行数据清洗，判断一个字符串是否包含特定的子字符串（或“针”，needle）都是一项核心技能。理解PHP提供的不同函数及其细微差别，对于编写高效、健壮且易于维护的代码至关重要。

PHP提供了从简单布尔判断到复杂正则表达式匹配的多种方法来检测子字符串。每种方法都有其特定的优势和适用场景。我们将从最常用、最直接的方法开始，逐步深入到更高级和更专业的技巧。

一、最直接的选择：str_contains() (PHP 8+)

随着PHP 8.0的发布，一个名为 `str_contains()` 的新函数被引入，它极大地简化了子字符串检测的任务。这个函数的设计目标就是为了提高代码的可读性和简洁性。<?php
$haystack = "Hello, world! This is a test string.";
$needle1 = "world";
$needle2 = "php";
if (str_contains($haystack, $needle1)) {
echo "<p>'$haystack' 包含 '$needle1'</p>"; // 输出：'Hello, world! This is a test string.' 包含 'world'
} else {
echo "<p>'$haystack' 不包含 '$needle1'</p>";
}
if (str_contains($haystack, $needle2)) {
echo "<p>'$haystack' 包含 '$needle2'</p>";
} else {
echo "<p>'$haystack' 不包含 '$needle2'</p>"; // 输出：'Hello, world! This is a test string.' 不包含 'php'
}
// 示例：空子字符串
if (str_contains($haystack, '')) {
echo "<p>空字符串总被包含（技术上，它在每个字符之间以及字符串的开始和结束处都存在）</p>"; // 输出：空字符串总被包含
}
?>

特点与优势：
简洁直观： 函数名本身就清晰地表达了其功能。
返回布尔值： 直接返回 `true` 或 `false`，无需额外的比较操作。
性能优异： 对于简单的子字符串检测，其性能与 `strpos()` 相当，并且通常优于正则表达式。
大小写敏感： 默认情况下是大小写敏感的。如果你需要大小写不敏感的检测，你需要将两个字符串都转换为相同的大小写（例如使用 `strtolower()` 或 `strtoupper()`）再进行比较。
PHP 8.0+ 独有： 如果你的项目运行在较旧的PHP版本上，你将无法使用此函数。

最佳实践： 如果你的项目支持PHP 8.0及以上版本，并且你只需要判断子字符串是否存在，那么 `str_contains()` 无疑是首选。

二、经典之选：strpos() 和 stripos()

在 `str_contains()` 出现之前，`strpos()` 是PHP中判断子字符串存在性的“黄金标准”。它不仅能判断子字符串是否存在，还能返回其首次出现的位置。`stripos()` 是其大小写不敏感的版本。<?php
$haystack = "Hello, World! This is a test string.";
$needle1 = "World";
$needle2 = "php";
$needle3 = "hello"; // 注意大小写
// strpos() - 大小写敏感
if (strpos($haystack, $needle1) !== false) {
echo "<p>'$haystack' 包含 '$needle1' (strpos)</p>"; // 输出：'Hello, World! This is a test string.' 包含 'World' (strpos)
}
if (strpos($haystack, $needle2) !== false) {
// 不会输出
} else {
echo "<p>'$haystack' 不包含 '$needle2' (strpos)</p>"; // 输出：'Hello, World! This is a test string.' 不包含 'php' (strpos)
}
if (strpos($haystack, $needle3) !== false) {
// 不会输出，因为'hello'是小写
} else {
echo "<p>'$haystack' 不包含 '$needle3' (strpos)</p>"; // 输出：'Hello, World! This is a test string.' 不包含 'hello' (strpos)
}
// stripos() - 大小写不敏感
if (stripos($haystack, $needle3) !== false) {
echo "<p>'$haystack' 包含 '$needle3' (stripos)</p>"; // 输出：'Hello, World! This is a test string.' 包含 'hello' (stripos)
}
// 强调 !== false 的重要性
$haystack_start = "apple pie";
$needle_start = "apple";
if (strpos($haystack_start, $needle_start)) { // 错误用法！
echo "<p>这可能会导致错误判断，因为 'apple' 在位置 0。</p>";
}
if (strpos($haystack_start, $needle_start) !== false) { // 正确用法
echo "<p>正确判断：'$haystack_start' 包含 '$needle_start' 在位置 " . strpos($haystack_start, $needle_start) . "</p>"; // 输出：正确判断：'apple pie' 包含 'apple' 在位置 0
}
?>

工作原理：
`strpos($haystack, $needle, $offset = 0)`：在 `$haystack` 字符串中查找 `$needle` 第一次出现的位置。如果找到，返回其起始位置（从0开始计数）；如果未找到，返回 `false`。`$offset` 参数可以指定从哪个位置开始查找。
`stripos()`：功能与 `strpos()` 相同，但查找过程是大小写不敏感的。

关键点：`!== false` 的重要性

这是使用 `strpos()` 和 `stripos()` 时最容易出错的地方。如果子字符串在主字符串的开头（即位置0），`strpos()` 会返回 `0`。在PHP中，`0` 被视为“假值” (`falsey`)。因此，如果你写 `if (strpos(...)`，当子字符串在开头时，条件会被错误地判断为 `false`。为了避免这种歧义，你必须使用严格比较运算符 `!== false`。

最佳实践： 当你需要支持PHP 7及以下版本，或者你不仅需要判断是否存在，还需要获取子字符串的位置时，`strpos()` (`!== false`) 是一个可靠且高效的选择。对于大小写不敏感的场景，使用 `stripos()`。

三、获取匹配子字符串或剩余部分：strstr() 和 stristr()

`strstr()` 和 `stristr()` 不仅仅是判断子字符串是否存在，它们还能返回主字符串中从子字符串第一次出现位置开始，直到字符串末尾的部分。这在需要提取特定内容时非常有用。<?php
$email = "user@";
$domain = strstr($email, '@'); // $domain 会是 "@"
echo "<p>域名部分: " . $domain . "</p>"; // 输出：域名部分: @
$username = strstr($email, '@', true); // 设置第三个参数为 true，返回 '@' 之前的部分
echo "<p>用户名部分: " . $username . "</p>"; // 输出：用户名部分: user
$text = "PHP is great. php development is fun.";
$part1 = strstr($text, "php"); // 大小写敏感
echo "<p>strstr (敏感): " . ($part1 ? $part1 : "未找到") . "</p>"; // 输出：strstr (敏感): development is fun.
$part2 = stristr($text, "php"); // 大小写不敏感
echo "<p>stristr (不敏感): " . ($part2 ? $part2 : "未找到") . "</p>"; // 输出：stristr (不敏感): PHP is great. php development is fun.
if (strstr($email, 'notfound') === false) {
echo "<p>'notfound' 在 '$email' 中未找到 (strstr)</p>"; // 输出：'notfound' 在 'user@' 中未找到 (strstr)
}
?>

工作原理：
`strstr($haystack, $needle, $before_needle = false)`：查找 `$needle` 在 `$haystack` 中第一次出现的位置。如果找到，默认返回 `$needle` 及其之后的所有字符。如果第三个参数 `$before_needle` 设置为 `true`，则返回 `$needle` 之前的所有字符。如果未找到，返回 `false`。
`stristr()`：功能与 `strstr()` 相同，但查找过程是大小写不敏感的。

最佳实践： 当你不仅需要知道子字符串是否存在，还需要提取包含该子字符串或其之前/之后的部分时，`strstr()` 或 `stristr()` 是一个非常方便的选择。判断存在性时，也需要使用 `=== false` 进行严格比较。

四、强大的模式匹配：preg_match()

当子字符串检测需求变得更加复杂，例如需要匹配某种模式、多个可能的子字符串、或者进行更灵活的模糊匹配时，正则表达式是不可或缺的工具。PHP的 `preg_match()` 函数是处理这类场景的利器。<?php
$haystack = "My email is user@ and my phone is 123-456-7890.";
// 查找是否包含一个邮箱地址
if (preg_match("/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/", $haystack)) {
echo "<p>'$haystack' 包含一个邮箱地址。</p>"; // 输出：'My email is user@ and my phone is 123-456-7890.' 包含一个邮箱地址。
}
// 查找是否包含 'php' (大小写不敏感)
if (preg_match("/php/i", $haystack)) { // 'i' 修饰符表示大小写不敏感
echo "<p>'$haystack' 包含 'php' (大小写不敏感)。</p>"; // 不会输出，因为 haystack 中没有 php
} else {
echo "<p>'$haystack' 不包含 'php' (大小写不敏感)。</p>"; // 输出：'My email is user@ and my phone is 123-456-7890.' 不包含 'php' (大小写不敏感)。
}
$text_with_php = "Learn PHP and Python.";
if (preg_match("/php/i", $text_with_php)) {
echo "<p>'$text_with_php' 包含 'php' (大小写不敏感)。</p>"; // 输出：'Learn PHP and Python.' 包含 'php' (大小写不敏感)。
}
// 查找是否包含某个特定单词（避免匹配子串）
$sentence = "The cat sat on the mat. Catastrophe averted.";
if (preg_match("/\bcat\b/i", $sentence)) { // \b 是单词边界
echo "<p>'$sentence' 包含单词 'cat' (大小写不敏感)。</p>"; // 输出：'The cat sat on the mat. Catastrophe averted.' 包含单词 'cat' (大小写不敏感)。
}
?>

工作原理：
`preg_match($pattern, $subject, &$matches = null, $flags = 0, $offset = 0)`：尝试在 `$subject` 字符串中匹配 `$pattern` 正则表达式。如果匹配成功，返回 `1`；如果未找到匹配，返回 `0`；如果发生错误，返回 `false`。可选的 `$matches` 数组将保存所有匹配到的内容。

特点与优势：
极度灵活： 可以处理几乎任何复杂的模式匹配需求。
大小写控制： 通过正则表达式修饰符（如 `i`）可以轻松控制大小写敏感性。
捕获匹配： 可以捕获匹配到的子串或子组。
单词边界： 可以使用 `\b` 等特殊序列进行精确的单词匹配。

劣势：
性能开销： 对于简单的子字符串检测，正则表达式通常比直接的字符串函数慢，因为它涉及更复杂的解析和匹配引擎。
可读性： 复杂的正则表达式可能难以阅读和维护。

最佳实践： 仅在简单的字符串函数无法满足需求时才使用 `preg_match()`。例如，需要匹配多个备选项、检测特定格式（如电话号码、邮箱）、或者进行单词边界匹配。

五、处理多字节字符：mb_* 函数

在现代Web开发中，我们经常需要处理包含UTF-8等非ASCII字符的字符串（例如中文、日文、韩文等）。标准的字符串函数（如 `strpos()`, `strstr()`）是基于字节进行操作的，而不是字符。这意味着它们在处理多字节字符时可能会给出错误的结果或行为异常。

为了正确处理多字节字符串，PHP提供了多字节字符串（`mb_*`）函数系列。<?php
$haystack_mb = "你好世界，Hello World";
$needle_mb = "世界";
$needle_mb_wrong = "你好世"; // 错误的子字符串，但字节级别可能部分匹配
// 标准 strpos() 在处理 UTF-8 时可能出错
if (strpos($haystack_mb, $needle_mb) !== false) {
echo "<p>strpos() 找到 '$needle_mb' (可能正确，但不可靠)</p>"; // 可能输出，但位置不准确
}
// 使用 mb_strpos()
if (mb_strpos($haystack_mb, $needle_mb, 0, 'UTF-8') !== false) {
echo "<p>mb_strpos() 找到 '$needle_mb' (正确)</p>"; // 输出：mb_strpos() 找到 '世界' (正确)
}
if (mb_strpos($haystack_mb, $needle_mb_wrong, 0, 'UTF-8') !== false) {
echo "<p>mb_strpos() 找到 '$needle_mb_wrong' (正确判断未找到)</p>"; // 不会输出
} else {
echo "<p>mb_strpos() 未找到 '$needle_mb_wrong' (正确)</p>"; // 输出：mb_strpos() 未找到 '你好世' (正确)
}
// mb_stripos() - 多字节、大小写不敏感
$haystack_mb_case = "程序员是Coder，coder是很棒的。";
$needle_mb_case = "coder";
if (mb_stripos($haystack_mb_case, $needle_mb_case, 0, 'UTF-8') !== false) {
echo "<p>mb_stripos() 找到 '$needle_mb_case' (大小写不敏感)</p>"; // 输出：mb_stripos() 找到 'coder' (大小写不敏感)
}
// mb_strstr() 和 mb_stristr() 类似
$result_mb = mb_strstr($haystack_mb, $needle_mb, false, 'UTF-8');
echo "<p>mb_strstr() 结果: " . ($result_mb ? $result_mb : "未找到") . "</p>"; // 输出：mb_strstr() 结果: 世界，Hello World
?>

常用 `mb_*` 函数：
`mb_strpos($haystack, $needle, $offset = 0, $encoding = null)`
`mb_stripos($haystack, $needle, $offset = 0, $encoding = null)`
`mb_strstr($haystack, $needle, $before_needle = false, $encoding = null)`
`mb_stristr($haystack, $needle, $before_needle = false, $encoding = null)`

关键点： 务必指定正确的编码（通常是 `'UTF-8'`）。你也可以通过 `mb_internal_encoding()` 设置全局的内部编码。

最佳实践： 只要你的应用程序涉及多字节字符（几乎所有现代Web应用都会涉及），就应该优先使用 `mb_*` 函数。否则，你可能会遇到字符串截断、错误匹配或乱码等问题。

六、性能考量与选择策略

选择正确的子字符串检测方法不仅关乎功能实现，还关乎应用程序的性能。以下是一些通用的性能考量和选择策略：
PHP 8.0+ 简单布尔判断： `str_contains()` 是最推荐和性能最优的选择。
PHP < 8.0 简单布尔判断或需要位置： `strpos($haystack, $needle) !== false` 是最高效且可靠的方法。
需要提取匹配部分： `strstr()` 或 `stristr()`。
多字节字符： 始终使用 `mb_strpos()`、`mb_strstr()` 等 `mb_*` 族函数，并指定编码。
复杂模式匹配： 只有在简单字符串函数无法满足需求时，才使用 `preg_match()`。其性能开销相对较高。
性能微优化： 对于非常长的字符串或需要进行大量查找的场景，确保 `$needle` 的长度不会过短（空字符串或单个字符的查找会更耗时），并考虑从字符串的中间开始查找（通过 `$offset` 参数）以优化性能，但这通常是高级优化。

七、总结与最佳实践

PHP提供了丰富而强大的工具来判断字符串是否包含子字符串。理解它们各自的特点和适用场景，是编写高效、健壮代码的关键。
PHP 8.0+ 首选 `str_contains()`： 如果你只需要判断是否存在，且项目环境允许，这是最简洁、最直观、性能优秀的选择。
旧版本或需要位置时使用 `strpos()`/`stripos()`： 记住使用 `!== false` 进行严格比较，以避免 `0` 的假值陷阱。
需要提取部分字符串时使用 `strstr()`/`stristr()`： 同样需要严格比较 `=== false` 来判断未找到的情况。
处理多字节字符时务必使用 `mb_*` 函数： 避免因字符编码问题导致的错误。
复杂模式匹配才用 `preg_match()`： 正则表达式功能强大，但性能开销也最大，不应用于简单的子字符串查找。
代码可读性优先： 在满足性能要求的前提下，选择最能清晰表达意图的函数。

通过熟练掌握这些字符串处理技巧，你将能够更有效地处理PHP开发中的各种文本数据，提高代码的质量和应用程序的性能。

2026-04-07

下一篇：PHP 数组数据添加深度解析：从基础到高级的高效实践指南