PHP判断字符串不包含子字符串：多种高效方法与最佳实践112

作为一名专业的程序员，在日常开发中，我们经常需要对字符串进行各种操作，其中之一就是判断一个字符串是否包含另一个子字符串。然而，有时我们的需求恰恰相反：我们需要确认一个字符串不包含某个特定的子字符串。这个看似简单的逻辑，在PHP中却有多种实现方式，并且每种方式都有其适用场景、性能特点以及潜在的“陷阱”。本文将深入探讨PHP中判断字符串不包含某个子字符串的各种高效方法，并提供最佳实践，帮助您写出更健壮、更高效的代码。

字符串操作是任何编程语言的核心组成部分，PHP也不例外。无论是在处理用户输入、解析URL、验证数据格式，还是在生成动态内容时，判断字符串中是否缺失某个特定片段的需求都非常普遍。本文将详细讲解PHP中实现“字符串不包含子字符串”的几种主要方法，包括PHP 8+的新特性以及兼容旧版本的方案，并对它们的性能、易用性和注意事项进行全面分析。

一、最现代与推荐：PHP 8+ `str_contains()` 的反向判断

自 PHP 8.0 起，语言核心引入了一个非常方便、直观且高性能的函数 `str_contains()`，专门用于判断一个字符串是否包含另一个子字符串。它的设计就是为了解决过去使用 `strpos()` 结合 `!== false` 判断的常见困惑，让代码更具可读性。因此，在支持 PHP 8.0 及更高版本的项目中，判断不包含子字符串的最佳方法就是对 `str_contains()` 的结果取反。

1.1 `str_contains()` 函数简介

`str_contains(string $haystack, string $needle): bool`
`$haystack`: 要搜索的字符串（主字符串）。
`$needle`: 要查找的子字符串。
返回值：如果 `$haystack` 包含 `$needle`，则返回 `true`；否则返回 `false`。

1.2 实现“不包含”的逻辑

由于 `str_contains()` 返回一个布尔值，我们只需要简单地对其结果进行逻辑非（`!`）操作即可。<?php
$mainString = "Hello, world! This is a test string.";
$substring1 = "world"; // 包含
$substring2 = "php"; // 不包含
$substring3 = "TEST"; // 不包含（区分大小写）
$substring4 = ""; // 空子字符串，始终被认为是包含的（PHP 8.0+ 的行为）
// 判断 $mainString 是否不包含 $substring1
if (!str_contains($mainString, $substring1)) {
echo "'$mainString' 不包含 '$substring1'. (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring1'. (预期: 包含)";
}
// 判断 $mainString 是否不包含 $substring2
if (!str_contains($mainString, $substring2)) {
echo "'$mainString' 不包含 '$substring2'. (预期: 不包含)";
} else {
echo "'$mainString' 包含 '$substring2'. (预期: 不包含)";
}
// 判断 $mainString 是否不包含 $substring3 (区分大小写)
if (!str_contains($mainString, $substring3)) {
echo "'$mainString' 不包含 '$substring3'. (预期: 不包含)";
} else {
echo "'$mainString' 包含 '$substring3'. (预期: 不包含)";
}
// 判断 $mainString 是否不包含空子字符串
if (!str_contains($mainString, $substring4)) {
echo "'$mainString' 不包含空字符串. (预期: 包含)";
} else {
echo "'$mainString' 包含空字符串. (预期: 包含)";
}
// 输出:
// 'Hello, world! This is a test string.' 包含 'world'. (预期: 包含)
// 'Hello, world! This is a test string.' 不包含 'php'. (预期: 不包含)
// 'Hello, world! This is a test string.' 不包含 'TEST'. (预期: 不包含)
// 'Hello, world! This is a test string.' 包含空字符串. (预期: 包含)
?>

1.3 优缺点

优点：

极高的可读性： `!str_contains()` 表达的语义非常清晰，一眼就能看出是在判断“不包含”。
性能优异： 底层使用C语言实现，针对此场景进行了优化，效率很高。
避免陷阱： 不存在 `strpos()` 的 `0` 和 `false` 混淆问题。

缺点：

PHP版本限制： 仅适用于 PHP 8.0 及更高版本。对于旧项目，需要采用其他方法。
不支持大小写不敏感： `str_contains()` 是大小写敏感的。如果需要大小写不敏感的判断，仍需借助其他函数或先转换字符串大小写。

二、最常用与兼容旧版本：`strpos()` / `stripos()` 结合严格比较

在 PHP 8.0 之前，`strpos()` 和 `stripos()` （大小写不敏感版本）是判断字符串是否包含子字符串的“黄金标准”。但它们返回的是子字符串首次出现的位置（一个整数）或者 `false`（如果未找到），这就引入了一个著名的“陷阱”：子字符串可能出现在主字符串的开头（位置 `0`）。因此，判断不包含子字符串必须使用严格比较。

2.1 `strpos()` 函数简介

`strpos(string $haystack, string $needle, int $offset = 0): int|false`
`$haystack`: 要搜索的字符串。
`$needle`: 要查找的子字符串。
`$offset`: 可选，从 `$haystack` 的哪个位置开始搜索。
返回值：如果找到 `$needle`，则返回它在 `$haystack` 中首次出现的数字位置（从0开始）。如果未找到，则返回 `false`。

2.2 实现“不包含”的逻辑 (大小写敏感)

核心在于：如果 `strpos()` 返回 `false`，则表示子字符串不存在。必须使用 `=== false` 进行严格比较，以避免将位置 `0` 误判为 `false`。<?php
$mainString = "Hello, world! This is a test string.";
$substring1 = "world";
$substring2 = "php";
$substring3 = "Hello"; // 子字符串在开头，位置为 0
$substring4 = "TEST"; // 不包含（区分大小写）
// 判断 $mainString 是否不包含 $substring1
if (strpos($mainString, $substring1) === false) {
echo "'$mainString' 不包含 '$substring1'. (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring1'. (预期: 包含)";
}
// 判断 $mainString 是否不包含 $substring2
if (strpos($mainString, $substring2) === false) {
echo "'$mainString' 不包含 '$substring2'. (预期: 不包含)";
} else {
echo "'$mainString' 包含 '$substring2'. (预期: 不包含)";
}
// 强调陷阱：子字符串在位置 0 的情况
if (strpos($mainString, $substring3) === false) {
echo "'$mainString' 不包含 '$substring3' (位于开头). (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring3' (位于开头). (预期: 包含)";
}
// 错误示范：使用 !strpos()
if (!strpos($mainString, $substring3)) { // 这里会错误地判断为“不包含”
echo "错误示范！ '!strpos()' 判断 '$mainString' 不包含 '$substring3'. (实际: 包含)";
} else {
echo "正确！ '!strpos()' 判断 '$mainString' 包含 '$substring3'. (实际: 包含)";
}
// 输出:
// 'Hello, world! This is a test string.' 包含 'world'. (预期: 包含)
// 'Hello, world! This is a test string.' 不包含 'php'. (预期: 不包含)
// 'Hello, world! This is a test string.' 包含 'Hello' (位于开头). (预期: 包含)
// 错误示范！ '!strpos()' 判断 'Hello, world! This is a test string.' 不包含 'Hello'. (实际: 包含)
?>

2.3 `stripos()` 实现大小写不敏感的“不包含”

`stripos()` 函数与 `strpos()` 类似，但它在查找子字符串时不区分大小写。用法和注意事项与 `strpos()` 完全相同，也需要使用 `=== false` 进行严格比较。<?php
$mainString = "Hello, world! This is a test string.";
$substring1 = "TEST"; // 实际存在 'test'
// 判断 $mainString 是否不包含 $substring1 (不区分大小写)
if (stripos($mainString, $substring1) === false) {
echo "'$mainString' 不包含 '$substring1' (大小写不敏感). (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring1' (大小写不敏感). (预期: 包含)";
}
// 输出:
// 'Hello, world! This is a test string.' 包含 'TEST' (大小写不敏感). (预期: 包含)
?>

2.4 优缺点

优点：

兼容性好： 适用于所有主流的 PHP 版本。
性能优异： 底层同样是C语言实现，效率很高，尤其是在子字符串出现在主字符串开头时，能快速返回结果。
大小写控制： `strpos()` 提供大小写敏感，`stripos()` 提供大小写不敏感。

缺点：

易犯“陷阱”： 必须使用 `=== false` 进行严格比较，否则容易将位置 `0` 误判为 `false`，导致逻辑错误。这是 `strpos()` 最常见的错误用法。
可读性稍逊： 相对于 `!str_contains()`，`strpos(...) === false` 稍微复杂一点。

三、使用 `strstr()` / `stristr()` 函数

`strstr()` 和 `stristr()` 函数用于查找子字符串的首次出现，并返回子字符串从主字符串中开始直到主字符串末尾的部分。如果未找到子字符串，则返回 `false`。

3.1 `strstr()` 函数简介

`strstr(string $haystack, string $needle, bool $before_needle = false): string|false`
`$haystack`: 要搜索的字符串。
`$needle`: 要查找的子字符串。
`$before_needle`: 可选。如果设置为 `true`，则返回 `$needle` 之前的部分；否则返回 `$needle` 及其之后的部分。
返回值：如果找到 `$needle`，则返回子字符串从主字符串中开始直到主字符串末尾的部分（或之前的部分）。如果未找到，则返回 `false`。

3.2 实现“不包含”的逻辑 (大小写敏感)

与 `strpos()` 类似，当 `strstr()` 返回 `false` 时，表示子字符串不存在。同样需要严格比较。<?php
$mainString = "Hello, world! This is a test string.";
$substring1 = "world";
$substring2 = "php";
// 判断 $mainString 是否不包含 $substring1
if (strstr($mainString, $substring1) === false) {
echo "'$mainString' 不包含 '$substring1'. (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring1'. (预期: 包含)";
}
// 判断 $mainString 是否不包含 $substring2
if (strstr($mainString, $substring2) === false) {
echo "'$mainString' 不包含 '$substring2'. (预期: 不包含)";
} else {
echo "'$mainString' 包含 '$substring2'. (预期: 不包含)";
}
// 输出:
// 'Hello, world! This is a test string.' 包含 'world'. (预期: 包含)
// 'Hello, world! This is a test string.' 不包含 'php'. (预期: 不包含)
?>

3.3 `stristr()` 实现大小写不敏感的“不包含”

`stristr()` 是 `strstr()` 的大小写不敏感版本，用法和注意事项也完全相同。<?php
$mainString = "Hello, world! This is a test string.";
$substring1 = "TEST";
// 判断 $mainString 是否不包含 $substring1 (不区分大小写)
if (stristr($mainString, $substring1) === false) {
echo "'$mainString' 不包含 '$substring1' (大小写不敏感). (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring1' (大小写不敏感). (预期: 包含)";
}
// 输出:
// 'Hello, world! This is a test string.' 包含 'TEST' (大小写不敏感). (预期: 包含)
?>

3.4 优缺点

优点：

兼容性好： 适用于所有主流的 PHP 版本。
灵活： 如果除了判断是否存在，还需要获取子字符串之后（或之前）的部分，那么 `strstr()` 更加方便。

缺点：

性能： 相对于 `strpos()`，`strstr()` 需要返回或构造一个子字符串，理论上在仅需要布尔判断时，可能会有轻微的性能损失（虽然通常可以忽略不计）。
易犯“陷阱”： 与 `strpos()` 类似，也需要使用 `=== false` 进行严格比较。
可读性： 对于只判断是否存在的需求，不如 `!str_contains()` 或 `strpos(...) === false` 直观。

四、功能最强大但可能过重：`preg_match()` 的反向判断

正则表达式（Regular Expressions）是处理复杂字符串模式匹配的利器。`preg_match()` 函数可以根据正则表达式模式在字符串中进行搜索。虽然对于简单的子字符串查找可能显得有些“大材小用”，但它在处理更复杂的“不包含”条件时（例如不包含数字、不包含特殊字符、不包含特定模式的URL等）是不可替代的。

4.1 `preg_match()` 函数简介

`preg_match(string $pattern, string $subject, array &$matches = null, int $flags = 0, int $offset = 0): int|false`
`$pattern`: 要匹配的正则表达式模式。
`$subject`: 要搜索的字符串。
返回值：如果找到匹配，返回 `1`；未找到返回 `0`；发生错误返回 `false`。

4.2 实现“不包含”的逻辑

`preg_match()` 返回 `0` 表示没有匹配。因此，我们可以检查其返回值是否为 `0`，或者更常见地，对其返回值取反（`!`）来判断“不包含”。<?php
$mainString = "Hello, world! This is a test string.";
$substring1 = "world";
$substring2 = "php";
$substring3 = "TEST"; // 大小写不敏感模式
// 判断 $mainString 是否不包含 $substring1 (简单模式)
// 注意：正则表达式中的特殊字符需要转义，例如 "." "+" "*" "?" 等，但对于纯文本子字符串，通常无需转义。
// 为了更安全，可以使用 preg_quote()
$pattern1 = '/' . preg_quote($substring1, '/') . '/'; // "/world/"
if (!preg_match($pattern1, $mainString)) {
echo "'$mainString' 不包含 '$substring1'. (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring1'. (预期: 包含)";
}
// 判断 $mainString 是否不包含 $substring2
$pattern2 = '/' . preg_quote($substring2, '/') . '/'; // "/php/"
if (!preg_match($pattern2, $mainString)) {
echo "'$mainString' 不包含 '$substring2'. (预期: 不包含)";
} else {
echo "'$mainString' 包含 '$substring2'. (预期: 不包含)";
}
// 判断 $mainString 是否不包含 $substring3 (大小写不敏感模式，添加 'i' 修饰符)
$pattern3 = '/' . preg_quote($substring3, '/') . '/i'; // "/TEST/i"
if (!preg_match($pattern3, $mainString)) {
echo "'$mainString' 不包含 '$substring3' (大小写不敏感). (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring3' (大小写不敏感). (预期: 包含)";
}
// 更复杂的例子：不包含任何数字
$stringWithNumber = "Product_ID_123";
$stringWithoutNumber = "ProductName";
if (!preg_match('/\d/', $stringWithNumber)) { // '/\d/' 匹配任何数字
echo "'$stringWithNumber' 不包含数字. (预期: 包含)";
} else {
echo "'$stringWithNumber' 包含数字. (预期: 包含)";
}
if (!preg_match('/\d/', $stringWithoutNumber)) {
echo "'$stringWithoutNumber' 不包含数字. (预期: 不包含)";
} else {
echo "'$stringWithoutNumber' 包含数字. (预期: 不包含)";
}
// 输出:
// 'Hello, world! This is a test string.' 包含 'world'. (预期: 包含)
// 'Hello, world! This is a test string.' 不包含 'php'. (预期: 不包含)
// 'Hello, world! This is a test string.' 包含 'TEST' (大小写不敏感). (预期: 包含)
// 'Product_ID_123' 包含数字. (预期: 包含)
// 'ProductName' 不包含数字. (预期: 不包含)
?>

4.3 优缺点

优点：

功能强大： 能够处理任何复杂的模式匹配需求，包括通配符、字符集、边界匹配等。
灵活性高： 可以通过修饰符（如 `i` 区分大小写）轻松控制匹配行为。

缺点：

性能开销： 对于简单的子字符串查找，正则表达式引擎的初始化和匹配过程会带来额外的性能开销，通常比 `str_contains()` 或 `strpos()` 慢。
学习曲线： 正则表达式本身有学习门槛，模式可能难以阅读和维护。
可读性： 简单的 `!preg_match()` 可读性尚可，但复杂的正则表达式会大大降低代码可读性。

五、通过统计子字符串数量判断：`substr_count()`

`substr_count()` 函数返回子字符串在主字符串中出现的次数。如果次数为 `0`，则表示不包含。

5.1 `substr_count()` 函数简介

`substr_count(string $haystack, string $needle, int $offset = 0, ?int $length = null): int`
`$haystack`: 要搜索的字符串。
`$needle`: 要查找的子字符串。
返回值：子字符串出现的次数。

5.2 实现“不包含”的逻辑

当 `substr_count()` 返回 `0` 时，即表示主字符串中不包含该子字符串。<?php
$mainString = "Hello, world! This is a test string. world";
$substring1 = "world";
$substring2 = "php";
// 判断 $mainString 是否不包含 $substring1
if (substr_count($mainString, $substring1) === 0) {
echo "'$mainString' 不包含 '$substring1'. (预期: 包含)";
} else {
echo "'$mainString' 包含 '$substring1'. (预期: 包含)";
}
// 判断 $mainString 是否不包含 $substring2
if (substr_count($mainString, $substring2) === 0) {
echo "'$mainString' 不包含 '$substring2'. (预期: 不包含)";
} else {
echo "'$mainString' 包含 '$substring2'. (预期: 不包含)";
}
// 输出:
// 'Hello, world! This is a test string. world' 包含 'world'. (预期: 包含)
// 'Hello, world! This is a test string. world' 不包含 'php'. (预期: 不包含)
?>

5.3 优缺点

优点：

语义清晰： `substr_count(...) === 0` 非常直观地表达了“出现次数为零”的含义。
兼容性好： 适用于所有主流的 PHP 版本。

缺点：

性能： `substr_count()` 会扫描整个 `$haystack` 以计数所有出现次数。即使子字符串在开头就被找到，它也不会立即停止。因此，在仅需要判断是否存在时，它通常不如 `str_contains()` 或 `strpos()` 效率高，尤其对于长字符串和频繁操作的场景。
不支持大小写不敏感： `substr_count()` 是大小写敏感的。

六、性能考量与选择指南

选择哪种方法取决于您的具体需求、PHP 版本以及对性能和可读性的权衡。以下是一个简明的选择指南：

PHP 8.0 及更高版本，且仅需判断简单子字符串（大小写敏感）：

首选： `!str_contains($haystack, $needle)`。
原因： 最佳的可读性、性能和安全性（无陷阱）。

PHP 7.x 及更早版本，或需要大小写敏感/不敏感的简单子字符串判断：

首选： `strpos($haystack, $needle) === false` (大小写敏感) 或 `stripos($haystack, $needle) === false` (大小写不敏感)。
原因： 性能优异，兼容性好。务必使用 `=== false` 进行严格比较。

需要处理复杂匹配模式（例如通配符、字符集、不包含数字/特殊字符等）：

首选： `!preg_match('/pattern/', $haystack)`。
原因： 正则表达式的强大功能是其他函数无法替代的。
注意： 对于简单的子字符串，避免使用正则表达式，因为它会带来额外的性能开销。同时，确保对子字符串使用 `preg_quote()` 进行转义，以防其包含特殊正则表达式字符。

需要统计子字符串出现次数，同时也能判断是否不包含：

考虑： `substr_count($haystack, $needle) === 0`。
原因： 语义清晰。
注意： 仅在也需要计数时使用此方法，如果只需要布尔判断，它的性能通常不如 `strpos` 系列。

除了判断是否包含，还需要获取子字符串之前或之后的部分：

考虑： `strstr($haystack, $needle) === false` 或 `stristr($haystack, $needle) === false`。
原因： 这些函数在返回字符串片段方面有额外用途。

七、最佳实践与注意事项

无论选择哪种方法，以下是一些通用的最佳实践和注意事项：

类型安全： 确保传递给字符串函数的参数确实是字符串。PHP在某些情况下会自动进行类型转换，但明确的类型可以避免意外行为。

空字符串 `needle` 的处理：

`str_contains('', '')` 或 `str_contains('abc', '')` 在 PHP 8.0+ 都返回 `true` (空字符串被认为包含在任何字符串中)。
`strpos('abc', '')` 返回 `0`。
`preg_match('/(?:)/', 'abc')` 或 `preg_match('//', 'abc')` 返回 `1`。
`substr_count('abc', '')` 返回 `1`。
在使用这些函数时，请考虑空子字符串的语义是否符合您的预期。通常情况下，空子字符串应该被认为是“包含”的，因为可以在任何位置插入一个空字符串。

空字符串 `haystack` 的处理：

`str_contains('', 'a')` 返回 `false`。
`strpos('', 'a')` 返回 `false`。
`preg_match('/a/', '')` 返回 `0`。
`substr_count('', 'a')` 返回 `0`。
这符合直觉：空字符串不会包含任何非空子字符串。

可读性优先： 除非有明确的性能瓶颈或复杂逻辑需求，否则请优先选择可读性最高的方案。对于 PHP 8+ 项目，`!str_contains()` 是毋庸置疑的最佳选择。

避免重复造轮子： PHP标准库提供了非常丰富的字符串处理函数，善用它们而不是自己实现。

测试： 对您的字符串判断逻辑进行充分的单元测试，特别是包括边界情况（空字符串、子字符串在开头/结尾、长字符串等）。

判断PHP字符串不包含某个子字符串，有多种有效的方法可供选择。从现代化的 `!str_contains()`（PHP 8+），到经典的 `strpos() === false`（兼容性强，但需注意严格比较），再到功能强大的 `!preg_match()`（适用于复杂模式），每种方法都有其独特的价值。作为专业的程序员，我们应该根据项目的PHP版本、具体需求、性能考量以及代码可读性，明智地选择最合适的工具。通过理解这些函数的内部机制和潜在陷阱，我们能够编写出更高效、更健壮、更易于维护的字符串处理代码。

2025-11-05

上一篇：PHP文件上传安全深度解析：从到代码实践的全方位限制指南

下一篇：Nginx与PHP-FPM高效集成：从配置到优化，构建高性能Web环境