PHP字符串子串计数：高效查找与统计指定字符串出现次数的多种方法376

作为一名专业的程序员，我们经常需要对字符串进行各种操作，其中之一便是查询某个子字符串在主字符串中出现的次数。无论是进行数据清洗、文本分析、日志处理，还是简单的表单验证，这项功能都显得尤为重要。PHP作为一门功能强大的服务器端脚本语言，提供了多种灵活且高效的方法来实现这一目标。

本文将深入探讨PHP中查询字符串中包含几个相同字符串的多种方法，从最简单直接的函数到灵活强大的正则表达式，并详细分析它们的用法、优缺点、性能考量以及在不同场景下的最佳实践。通过阅读本文，您将能够根据具体需求，选择最适合的工具来解决字符串计数问题。

字符串计数的重要性与PHP的强大工具

在Web开发和数据处理中，字符串操作无处不在。统计特定子字符串在另一个字符串中出现的频率，是许多任务的基础。例如，您可能需要：
分析用户输入的文本中特定关键词的密度。
解析日志文件，统计特定错误或事件发生的次数。
进行文本匹配和替换前的预处理，了解目标模式出现的频率。
验证用户输入，例如限制某个字符或短语的重复次数。

PHP提供了一系列内置函数和强大的正则表达式引擎，使得实现这些功能变得轻而易举。了解并掌握这些工具，将极大地提升您的开发效率和代码质量。

方法一：使用 `substr_count()` 函数（最直接高效）

substr_count() 是PHP专门为统计子字符串出现次数而设计的函数，它是处理非重叠子字符串计数的首选方法，通常也是性能最好的。

函数签名

int substr_count ( string $haystack , string $needle [, int $offset = 0 [, int $length ]] )

$haystack：要搜索的主字符串。
$needle：要查找的子字符串。
$offset (可选)：指定从主字符串的哪个位置开始搜索。默认为 0。
$length (可选)：指定在主字符串中搜索的长度范围。

该函数返回子字符串在主字符串中出现的次数。

基本用法示例

<?php
$mainString = "PHP is a popular PHP scripting language. PHP is versatile.";
$subString = "PHP";
$count = substr_count($mainString, $subString);
echo "'{$subString}' 在字符串中出现了 {$count} 次。"; // 输出: 'PHP' 在字符串中出现了 3 次。
$mainString2 = "banana";
$subString2 = "ana";
$count2 = substr_count($mainString2, $subString2);
echo "'{$subString2}' 在字符串中出现了 {$count2} 次。"; // 输出: 'ana' 在字符串中出现了 1 次 (注意，'ana' 在 'banana' 中实际上出现了两次，但substr_count不计算重叠)。
?>

处理大小写不敏感

substr_count() 默认是大小写敏感的。如果需要进行大小写不敏感的计数，可以先将主字符串和子字符串都转换为大写或小写。<?php
$mainString = "PHP is a popular php scripting language. PhP is versatile.";
$subString = "php";
// 方法一：都转为小写
$countLower = substr_count(strtolower($mainString), strtolower($subString));
echo "大小写不敏感地，'{$subString}' 在字符串中出现了 {$countLower} 次。"; // 输出: 大小写不敏感地，'php' 在字符串中出现了 3 次。
// 方法二：都转为大写
$countUpper = substr_count(strtoupper($mainString), strtoupper($subString));
echo "大小写不敏感地，'{$subString}' 在字符串中出现了 {$countUpper} 次。"; // 输出: 大小写不敏感地，'php' 在字符串中出现了 3 次。
?>

指定搜索范围

您还可以通过 $offset 和 $length 参数来限制搜索的范围。<?php
$mainString = "applebananaappleorangeapple";
$subString = "apple";
// 从第6个字符（索引5）开始搜索
$countFromOffset = substr_count($mainString, $subString, 5);
echo "从索引5开始，'{$subString}' 出现了 {$countFromOffset} 次。"; // 输出: 从索引5开始，'apple' 出现了 2 次。
// 从第6个字符开始，搜索长度为10的范围
$countWithOffsetAndLength = substr_count($mainString, $subString, 5, 10);
echo "从索引5开始，长度为10的范围内，'{$subString}' 出现了 {$countWithOffsetAndLength} 次。"; // 输出: 从索引5开始，长度为10的范围内，'apple' 出现了 1 次。
?>

`substr_count()` 的局限性：不计算重叠子字符串

正如前面的 "banana" 例子所示，substr_count() 不会计算重叠的子字符串。例如，在 "aaaaa" 中查找 "aaa"，它只会返回 1，因为在找到第一个 "aaa" 后，它会从该匹配的末尾之后继续搜索，忽略了中间的重叠部分。<?php
$mainString = "aaaaa";
$subString = "aaa";
$count = substr_count($mainString, $subString);
echo "'{$subString}' 在 '{$mainString}' 中出现了 {$count} 次。"; // 输出: 'aaa' 在 'aaaaa' 中出现了 1 次。
// 预期可能为3 (aaaaa -> (aaa)aa, a(aaa)a, aa(aaa))
?>

如果您需要计算重叠的子字符串，请考虑使用接下来的方法。

方法二：使用循环和 `strpos()` / `stripos()` （更灵活，可处理重叠）

通过在一个循环中反复使用 strpos() 或 stripos()，我们可以手动控制搜索的起始位置，从而实现对重叠子字符串的计数，或者更精细地控制搜索逻辑。

函数签名

int|false strpos ( string $haystack , mixed $needle [, int $offset = 0 ] )：查找 $needle 在 $haystack 中第一次出现的位置，大小写敏感。
int|false stripos ( string $haystack , mixed $needle [, int $offset = 0 ] )：与 strpos() 相同，但大小写不敏感。

这两个函数在找到子字符串时返回其起始位置的索引（从 0 开始），未找到则返回 false。

非重叠计数（模拟 `substr_count()`）

虽然 substr_count() 更优，但了解这种手动实现方式有助于理解其原理。<?php
$mainString = "PHP is a popular PHP scripting language. PHP is versatile.";
$subString = "PHP";
$count = 0;
$offset = 0;
while (($pos = strpos($mainString, $subString, $offset)) !== false) {
$count++;
// 关键：为了避免重叠，将偏移量移动到当前匹配的末尾之后
$offset = $pos + strlen($subString);
}
echo "'{$subString}' 在字符串中出现了 {$count} 次 (strpos 非重叠)。"; // 输出: 'PHP' 在字符串中出现了 3 次 (strpos 非重叠)。
?>

重叠计数示例

要计算重叠的子字符串，每次找到匹配后，我们将偏移量只增加 1，而不是子字符串的长度，这样可以从下一个字符继续搜索，捕获重叠情况。<?php
$mainString = "aaaaa";
$subString = "aaa";
$count = 0;
$offset = 0;
while (($pos = strpos($mainString, $subString, $offset)) !== false) {
$count++;
// 关键：为了捕获重叠，只将偏移量增加1
$offset = $pos + 1;
}
echo "'{$subString}' 在 '{$mainString}' 中出现了 {$count} 次 (strpos 重叠)。"; // 输出: 'aaa' 在 'aaaaa' 中出现了 3 次 (strpos 重叠)。
// 大小写不敏感的重叠计数
$mainString2 = "AbcabcAbc";
$subString2 = "abc";
$count2 = 0;
$offset2 = 0;
while (($pos = stripos($mainString2, $subString2, $offset2)) !== false) { // 使用 stripos
$count2++;
$offset2 = $pos + 1;
}
echo "大小写不敏感地，'{$subString2}' 在 '{$mainString2}' 中出现了 {$count2} 次 (stripos 重叠)。"; // 输出: 大小写不敏感地，'abc' 在 'AbcabcAbc' 中出现了 3 次 (stripos 重叠)。
?>

优点与缺点

优点：能够灵活控制搜索逻辑，尤其适用于需要计算重叠子字符串的场景。可以轻松实现大小写不敏感的搜索。
缺点：相比 substr_count()，代码更为复杂，且在处理大量数据时，由于是循环迭代，性能可能稍逊一筹（特别是对于非重叠计数）。

方法三：使用正则表达式 `preg_match_all()` （最强大灵活）

当您需要更复杂的模式匹配（不仅仅是固定子字符串），或者需要以非常明确的方式处理重叠匹配时，正则表达式是无与伦比的选择。PHP的 `preg_match_all()` 函数可以查找所有匹配正则表达式的模式。

函数签名

int|false preg_match_all ( string $pattern , string $subject , array &$matches [, int $flags = 0 [, int $offset = 0 ]] )

$pattern：要搜索的正则表达式。
$subject：要搜索的主字符串。
$matches：一个数组，用于存储所有匹配项。
$flags (可选)：控制匹配结果的组织方式，如 PREG_PATTERN_ORDER 或 PREG_SET_ORDER。
$offset (可选)：指定从主字符串的哪个位置开始搜索。

该函数返回完全匹配的次数（可能为 0），或在发生错误时返回 false。

基本用法示例（非重叠）

<?php
$mainString = "PHP is a popular PHP scripting language. PHP is versatile.";
$subString = "PHP";
// 正则表达式模式，/i 表示大小写不敏感
$pattern = "/" . preg_quote($subString, '/') . "/i"; // preg_quote 防止特殊字符被解释为正则表达式元字符
$count = preg_match_all($pattern, $mainString, $matches);
echo "'{$subString}' (大小写不敏感) 在字符串中出现了 {$count} 次 (preg_match_all)。"; // 输出: 'PHP' (大小写不敏感) 在字符串中出现了 3 次 (preg_match_all)。
print_r($matches); // $matches 数组会包含所有匹配项
/*
Array
(
[0] => Array
(
[0] => PHP
[1] => PHP
[2] => PHP
)
)
*/
?>

上面的示例中，preg_quote() 是一个非常重要的函数，它会转义子字符串中的任何正则表达式特殊字符，确保它被当作字面量来匹配。/i 修饰符使匹配大小写不敏感。

计算重叠子字符串（使用零宽断言 Lookahead）

正则表达式提供了一种强大的机制来处理重叠匹配：零宽先行断言（Lookahead Assertion），语法为 (?=pattern)。它会尝试匹配 pattern，但不会将匹配的字符消耗掉（即不会移动匹配指针），因此后续的匹配可以从当前位置继续。<?php
$mainString = "aaaaa";
$subString = "aaa";
// 使用 (?=...) 进行零宽先行断言
$pattern = "/(?=" . preg_quote($subString, '/') . ")/";
$count = preg_match_all($pattern, $mainString, $matches);
echo "'{$subString}' 在 '{$mainString}' 中出现了 {$count} 次 (preg_match_all 重叠)。"; // 输出: 'aaa' 在 'aaaaa' 中出现了 3 次 (preg_match_all 重叠)。
print_r($matches);
/*
Array
(
[0] => Array
(
[0] =>
[1] =>
[2] =>
)
)
*/
?>

注意，在使用零宽先行断言时，$matches 数组中的匹配结果可能是空字符串，因为先行断言本身不消耗字符。但它仍然会准确地统计出匹配的“位置”或“机会”数量。

更复杂的模式匹配

preg_match_all() 的真正力量在于它可以匹配复杂的模式，而不仅仅是固定的子字符串。<?php
$text = "The quick brown fox jumps over the lazy dog. Fox is agile.";
// 统计所有以 'f' 或 'F' 开头，后面跟着 'ox' 的单词
$count = preg_match_all("/\b[Ff]ox\b/", $text, $matches);
echo "匹配 'Fox' (单词边界) 的次数：{$count}。"; // 输出: 匹配 'Fox' (单词边界) 的次数：2。
print_r($matches[0]); // Array ( [0] => fox [1] => Fox )
?>

优点与缺点

优点：极其灵活和强大，可以处理任何复杂的模式匹配需求，包括精确的重叠计数。支持丰富的正则表达式功能（如字符类、量词、分组等）。
缺点：正则表达式的学习曲线较陡峭，对于简单的固定子字符串计数，性能通常不如 substr_count()。如果模式过于复杂或数据量极大，可能会有性能开销。

方法四：使用 `explode()` 函数（特定场景，不推荐用于计数）

尽管 explode() 函数的主要目的是将字符串分割成数组，但有时开发者会误用它来计数。其基本思路是，如果子字符串将主字符串分割成 N 个部分，那么子字符串就出现了 N-1 次。

函数签名

array explode ( string $separator , string $string [, int $limit = PHP_INT_MAX ] )

用法示例

<?php
$mainString = "apple,banana,cherry,date";
$subString = ",";
$parts = explode($subString, $mainString);
$count = count($parts) - 1;
echo "'{$subString}' 在字符串中出现了 {$count} 次 (explode)。"; // 输出: ',' 在字符串中出现了 3 次 (explode)。
$mainString2 = "applebananaappleorangeapple";
$subString2 = "apple";
$parts2 = explode($subString2, $mainString2);
$count2 = count($parts2) - 1;
echo "'{$subString2}' 在字符串中出现了 {$count2} 次 (explode)。"; // 输出: 'apple' 在字符串中出现了 3 次 (explode)。
// 注意：如果主字符串以子字符串开头或结尾，结果可能不符合预期，需要额外处理空字符串部分。
?>

局限性

无法处理重叠子字符串。
当子字符串出现在主字符串的开头或结尾时，explode() 会生成空字符串作为数组元素，这可能导致计数偏差，需要额外逻辑处理。
explode() 会创建并填充一个新数组，这在内存和性能上通常不如 substr_count() 或 strpos() 循环高效，尤其是在处理大型字符串时。

除非您真的需要将字符串分割成数组，否则不建议使用 explode() 进行子字符串计数。

性能考量与最佳实践

在选择方法时，性能是一个重要的考虑因素，尤其是在处理大量文本或高并发请求的场景下。

简要性能对比（经验法则）：

`substr_count()`：对于简单的非重叠子字符串计数，通常是性能最好的。它是用C语言实现的，效率极高。
`strpos()` / `stripos()` 循环：对于需要重叠计数或更精细控制的情况，其性能通常优于正则表达式，但比 `substr_count()` 慢。
`preg_match_all()`：最通用和强大的方法，但由于需要编译和执行正则表达式，通常在处理简单固定子字符串时比前两者慢。然而，对于复杂的模式匹配，它可能是唯一可行的选择。
`explode()`：最不推荐用于计数，因为它会生成额外的数组，消耗更多内存和CPU周期。

选择指南：

最简单、最快、非重叠、固定子字符串计数：始终优先使用 substr_count()。如果需要大小写不敏感，先将字符串转换为统一大小写再计数。
需要重叠计数、固定子字符串：考虑使用 strpos() / stripos() 循环，将 $offset 每次增加 1。
需要复杂模式匹配、重叠或非重叠、以及正则表达式的强大功能：使用 preg_match_all()。对于重叠匹配，别忘了使用零宽先行断言 (?=...)。
避免使用 `explode()` 进行计数。

示例：一个简单的性能测试

<?php
$mainString = str_repeat("PHP is great, PHP is useful, php is powerful. ", 1000); // 制造一个长字符串
$subString = "php";
echo "<h3>性能测试</h3>";
// substr_count (大小写不敏感)
$startTime = microtime(true);
$count_substr_count = substr_count(strtolower($mainString), strtolower($subString));
$endTime = microtime(true);
echo "substr_count: {$count_substr_count} 次, 耗时: " . round(($endTime - $startTime) * 1000, 2) . " ms";
// strpos 循环 (大小写不敏感, 重叠)
$startTime = microtime(true);
$count_strpos = 0;
$offset = 0;
while (($pos = stripos($mainString, $subString, $offset)) !== false) {
$count_strpos++;
$offset = $pos + 1; // 重叠计数
}
$endTime = microtime(true);
echo "strpos 循环 (重叠): {$count_strpos} 次, 耗时: " . round(($endTime - $startTime) * 1000, 2) . " ms";
// preg_match_all (大小写不敏感, 重叠)
$startTime = microtime(true);
$pattern = "/(?=" . preg_quote($subString, '/') . ")/i";
$count_preg_match_all = preg_match_all($pattern, $mainString, $matches);
$endTime = microtime(true);
echo "preg_match_all (重叠): {$count_preg_match_all} 次, 耗时: " . round(($endTime - $startTime) * 1000, 2) . " ms";
?>

运行上述代码，您会发现 substr_count 通常是最快的，即使它不处理重叠。strpos 循环对于重叠计数比 preg_match_all 通常更快，但 preg_match_all 在处理复杂模式时是无可替代的。

处理边缘情况

在实际应用中，还需要考虑一些边缘情况：
空主字符串 (`$haystack`)：所有方法都会返回 0。
空子字符串 (`$needle`)：

substr_count()：会返回 strlen($haystack) + 1。这是一个特殊行为，表示空字符串可以在每个字符之间和字符串两端出现。
strpos()：如果 $offset 小于 strlen($haystack)，会返回 $offset；否则返回 false。循环将陷入无限循环，需要特殊处理。
preg_match_all()：通常会匹配所有可能的位置，可能导致无限循环或大量匹配（取决于具体模式）。

因此，在实际开发中，务必检查 $needle 是否为空，并根据业务逻辑决定如何处理。
子字符串不存在：所有方法都会返回 0。

PHP提供了多种灵活且强大的方法来查询字符串中包含的相同子字符串的次数。理解每种方法的特点和适用场景是高效编程的关键：
对于简单的非重叠子字符串计数（默认需求），`substr_count()` 是最佳选择，性能最高。
对于需要计算重叠子字符串，或者需要更细粒度地控制搜索逻辑，`strpos()` / `stripos()` 结合循环是一个非常好的手动实现方案。
对于复杂的模式匹配（不仅仅是固定子字符串），或者需要确保准确处理重叠匹配（使用零宽先行断言），`preg_match_all()` 配合正则表达式是最终的利器。

作为专业的程序员，我们应该根据具体的需求、性能要求和代码可读性，明智地选择最合适的工具。避免在简单任务中使用过于复杂的工具，也切勿在需要强大功能时限制自己。

希望本文能帮助您全面理解PHP中字符串计数的方法，并在日常开发中运用自如！

2025-09-30

上一篇：PHP文件读取性能优化：从函数选择到实战策略

下一篇：PHP 连接与查询 MySQL 数据库：从入门到安全实践