PHP删除数组元素的几种方法

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《PHP删除数组元素方法详解》，聊聊，我们一起来看看吧！

删除数组元素需根据场景选择方法：unset()按键删除但留空洞；array_splice()可重新索引，适合连续删除；array_diff()按值删除；array_filter()按条件灵活删除。

PHP中从数组中删除元素的方式有很多，没有绝对的“最好”，只有最适合你当前需求和数组结构的。最直接的是unset()，它能按键快速删除，但可能会留下“空洞”；如果需要按值删除或删除一段连续的元素并保持索引连续，那么array_splice()、array_diff()或array_filter()会是更灵活、更优雅的选择。理解它们的差异和适用场景，能让你在实际开发中事半功倍。

解决方案

在PHP中，移除数组元素是日常操作，但选择哪种方法，往往取决于你删除的逻辑（按键、按值、按条件）、数组的类型（索引数组、关联数组）以及你是否关心删除后的键名重排。我个人在实践中，最常用的就是以下几种：

1. 使用 unset()：按键删除，最直接但有“副作用”

unset() 是PHP中销毁变量的函数，当然也能用来删除数组中的一个或多个元素。它的优点是操作直接，性能通常也很好。

$fruits = ['apple', 'banana', 'orange', 'grape'];
unset($fruits[1]); // 删除索引为1的元素 'banana'
print_r($fruits);
// 输出：Array ( [0] => apple [2] => orange [3] => grape )

$user = ['id' => 1, 'name' => 'Alice', 'email' => 'alice@example.com'];
unset($user['email']); // 删除键为 'email' 的元素
print_r($user);
// 输出：Array ( [id] => 1 [name] => Alice )

我的看法： unset() 的缺点在于，如果你删除的是一个数字索引数组的元素，它并不会自动重新索引。这意味着数组中会出现“空洞”，比如上面的 $fruits 数组，索引1消失了，但2和3还在。这在某些场景下可能会导致问题，比如当你期望数组索引是连续的（从0开始递增）时。对于关联数组，这倒不是问题，因为关联键本身就没有连续性的要求。

2. 使用 array_splice()：按索引范围删除并可重新索引

array_splice() 是一个非常强大的函数，它能移除数组的一部分，并可以用其他元素替换。更重要的是，它会重新索引数字键名。

$colors = ['red', 'green', 'blue', 'yellow', 'purple'];

// 删除从索引1开始的2个元素 ('green', 'blue')
array_splice($colors, 1, 2);
print_r($colors);
// 输出：Array ( [0] => red [1] => yellow [2] => purple )
// 注意：索引被重新排列了！

$data = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];
// array_splice 也能用于关联数组，但通常不建议，因为它的设计更偏向于数字索引
// 如果用在关联数组上，它会按数字顺序处理，可能不是你想要的
// array_splice($data, 1, 1); // 这会删除第二个元素（'b' => 2），并重新索引数字键，但关联键会丢失

我的看法： 当你需要删除数组中连续的一段元素，并且希望删除后数组的数字索引能自动“补齐”时，array_splice() 是不二之选。它直接修改原数组，非常方便。但如果只是删除一个特定键的元素，或者处理关联数组，我通常不会优先考虑它，因为它的操作逻辑是基于偏移量和长度，对关联数组来说有点别扭。

3. 使用 array_diff() 或 array_diff_assoc()：按值删除

如果你想删除数组中所有匹配某个特定值的元素，array_diff() 是个不错的选择。它会返回第一个数组中存在但不在其他任何数组中的值。

$numbers = [1, 2, 3, 4, 2, 5];
$toRemove = [2]; // 要删除的值
$result = array_diff($numbers, $toRemove);
print_r($result);
// 输出：Array ( [0] => 1 [2] => 3 [3] => 4 [5] => 5 )
// 注意：原始键名被保留了！

$items = ['a' => 'apple', 'b' => 'banana', 'c' => 'apple'];
$toRemoveValues = ['apple'];
$resultAssoc = array_diff($items, $toRemoveValues);
print_r($resultAssoc);
// 输出：Array ( [b] => banana )

如果你不仅要比较值，还要比较键，可以使用 array_diff_assoc()。

$array1 = ['a' => 'green', 'b' => 'brown', 'c' => 'blue', 'red'];
$array2 = ['a' => 'green', 'yellow', 'red'];
$resultAssocDiff = array_diff_assoc($array1, $array2);
print_r($resultAssocDiff);
// 输出：Array ( [b] => brown [c] => blue [0] => red )
// 'a' => 'green' 键值都相同，被移除了。
// 'red' 在 $array1 中是数字键 0，在 $array2 中是数字键 1，键不同，所以保留。

我的看法： array_diff() 系列函数非常适合当你明确知道要删除哪些“值”时。它不会修改原数组，而是返回一个新的数组。需要注意的是，它会保留原始数组的键名，如果你需要重新索引，还得再用 array_values() 包裹一下。

4. 使用 array_filter()：按条件删除，最灵活

array_filter() 可能是最灵活的删除方式，因为它允许你通过一个回调函数来定义删除的条件。回调函数返回 true 的元素会被保留，返回 false 的元素则被删除。

$scores = [85, 92, 78, 95, 60, 88];

// 删除所有低于80分的元素
$passedScores = array_filter($scores, function($score) {
    return $score >= 80;
});
print_r($passedScores);
// 输出：Array ( [0] => 85 [1] => 92 [3] => 95 [5] => 88 )
// 同样，原始键名被保留了。

$products = [
    ['id' => 1, 'name' => 'Laptop', 'price' => 1200],
    ['id' => 2, 'name' => 'Mouse', 'price' => 25],
    ['id' => 3, 'name' => 'Keyboard', 'price' => 75]
];

// 删除价格低于50的商品
$expensiveProducts = array_filter($products, function($product) {
    return $product['price'] >= 50;
});
print_r($expensiveProducts);
// 输出：Array ( [0] => Array ( [id] => 1 [name] => Laptop [price] => 1200 ) [2] => Array ( [id] => 3 [name] => Keyboard [price] => 75 ) )

我的看法： array_filter() 是我的“瑞士军刀”。当删除逻辑比较复杂，需要根据元素的某个属性或多个条件来判断时，它总能派上用场。它也返回一个新数组并保留原始键名，所以如果需要连续索引，别忘了 array_values()。

PHP删除数组元素后如何避免键值空洞或重新索引？

这是一个非常常见且容易让人困惑的问题，特别是对于那些从其他语言转过来的人。unset() 留下的“空洞”在PHP中是一个设计选择，它让开发者可以选择保留原始键名，这在关联数组中非常有用。但对于数字索引数组，你通常会希望索引是连续的，从0开始。

避免键值空洞或实现重新索引，主要有几种策略：

1. 使用 array_values() 重新索引： 这是最直接、最常用的方法。无论你使用 unset()、array_diff() 还是 array_filter()，只要结果数组的键名不是你想要的连续数字索引，你都可以用 array_values() 来重置它们。

   $data = ['a', 'b', 'c', 'd'];
   unset($data[1]); // 删除 'b'
   $data = array_values($data); // 重新索引
   print_r($data);
   // 输出：Array ( [0] => a [1] => c [2] => d )

   我的思考： 这种方式非常清晰，意图明确。先删除，再统一处理索引。我个人在处理完 unset() 或 array_filter() 之后，如果需要一个紧凑的数字索引数组，几乎都会条件反射地加上 array_values()。

2. 选择会重新索引的方法：array_splice() 正如前面提到的，array_splice() 在删除元素后会自动重新索引数字键名。如果你删除的是连续的元素，并且希望索引连续，那么直接使用 array_splice() 会省去 array_values() 这一步。

   $items = ['item1', 'item2', 'item3', 'item4'];
   array_splice($items, 1, 1); // 删除 'item2'
   print_r($items);
   // 输出：Array ( [0] => item1 [1] => item3 [2] => item4 )

   我的思考： array_splice() 在处理列表或队列这类需要严格顺序和连续索引的数据时非常方便。但如果删除逻辑复杂，或者删除的元素不连续，它的适用性就下降了。

3. 迭代构建新数组（适用于复杂条件）： 在某些非常复杂的情况下，例如你需要根据多个条件删除，并且删除后需要对剩余元素进行一些转换，或者仅仅是想完全控制新数组的结构，那么手动迭代并构建一个新数组也是一个选择。

   $users = [
       ['id' => 1, 'name' => 'Alice', 'active' => true],
       ['id' => 2, 'name' => 'Bob', 'active' => false],
       ['id' => 3, 'name' => 'Charlie', 'active' => true]
   ];
   $activeUsers = [];
   foreach ($users as $user) {
       if ($user['active']) {
           $activeUsers[] = $user; // 自动重新索引
       }
   }
   print_r($activeUsers);
   // 输出：Array ( [0] => Array ( [id] => 1 [name] => Alice [active] => 1 ) [1] => Array ( [id] => 3 [name] => Charlie [active] => 1 ) )

   我的思考： 这种方法虽然看起来有点“笨”，但它提供了最大的灵活性。当你需要对数组元素进行更精细的控制，或者在过滤的同时进行数据转换时，它是一个可靠的选择。array_filter() 内部其实也类似这种逻辑，但手动实现可以更进一步。

何时不关心重新索引？ 如果你处理的是关联数组，或者你只是遍历数组而不需要依赖连续的数字索引（例如 foreach ($array as $key => $value)），那么键值空洞通常不是问题，甚至保留原始键名可能更有意义。比如，你有一个用户列表，每个用户ID都是唯一的键，你删除一个用户后，其他用户的ID（键）保持不变，这反而是你想要的。

PHP在删除数组元素时有哪些性能考量和最佳实践？

谈到性能，这通常是大型应用或处理海量数据时才需要深入考虑的问题。对于小数组（几十几百个元素），不同删除方法之间的性能差异几乎可以忽略不计。但一旦数据量达到几万、几十万甚至上百万级别，选择合适的策略就显得尤为重要。

性能考量：

1. unset()：

   • 优点： 通常是最快的。它只是将内部指针指向的内存标记为可回收，并不会移动其他元素。对于删除单个元素，它的开销极小。
   • 缺点： 留下键值空洞。如果后续需要 array_values() 来重新索引，那么 array_values() 本身会遍历整个数组并创建新数组，这会增加开销。

2. array_splice()：

   • 优点： 自动重新索引，对于删除连续的元素很方便。
   • 缺点： 当删除数组中间或靠前的元素时，PHP内部需要移动所有后续元素来填补空缺。对于非常大的数组，如果删除操作频繁或删除位置靠前，这会是一个相对耗时的操作。

3. array_diff() / array_filter()：

   • 优点： 提供了基于值或条件的灵活删除方式。它们都返回一个新数组，不修改原数组。
   • 缺点： 它们都需要遍历整个数组（或部分数组），并且会创建新的数组来存储结果。这意味着额外的内存分配和复制操作。array_filter() 的性能还会受到回调函数复杂度的影响。

我的经验之谈：

• 小数组（<1000元素）： 随便用，选择你觉得最清晰、最符合逻辑的方法。性能差异可以忽略不计。我通常倾向于 unset() + array_values() 或 array_filter() + array_values()，因为它们的语义很清晰。
• 中等数组（1000-100000元素）：
  • 如果只是删除一个或少数几个已知键的元素，unset() 仍然是首选。
  • 如果需要删除大量元素且不关心键名，array_filter() 配合简单的回调函数通常表现不错。
  • array_splice() 在删除连续片段时效率尚可，但频繁在数组头部或中部删除会逐渐显现性能瓶颈。
• 大型数组（>100000元素）：
  • 避免频繁 array_splice() 中间元素。 这种操作在底层涉及大量内存拷贝。
  • 考虑批处理： 如果需要删除大量不连续的元素，可以考虑先收集所有要删除的键或值，然后一次性通过 array_filter() 或 array_diff() 处理，或者迭代构建一个新数组。
  • 利用 array_flip() 优化 array_diff()： 如果要删除的元素是值，且这些值是唯一的，可以考虑将数组 array_flip() 变成 值 => 键 的形式，然后用 unset() 删除，再 array_flip() 回来。但这只适用于特定场景。
  • 数据结构选择： 如果数组的删除操作极其频繁，且性能是关键，你可能需要重新评估是否应该使用PHP原生数组。例如，如果你的场景更像一个队列或栈，PHP的 SplQueue 或 SplStack 可能更适合。如果需要快速查找和删除，哈希表（关联数组本质上就是）是高效的，但如果需要有序且快速删除中间元素，可能需要更复杂的数据结构或数据库方案。

最佳实践：

1. 选择最符合语义的方法： 不要为了微小的性能提升而牺牲代码的可读性和维护性。
2. 明确是否需要重新索引： 这是删除操作后最常见的“坑”。如果需要，记得使用 array_values() 或选择 array_splice()。
3. 避免在循环中对同一个数组进行多次 array_splice() 或 array_filter()： 每次操作都可能导致数组重构，效率低下。尽可能地将删除逻辑合并，一次性处理。
4. 先测试，再优化： 如果你真的遇到了性能问题，先用实际数据进行基准测试（benchmark），找出瓶颈所在，然后再有针对性地优化。不要过早优化。
5. 警惕内存消耗： array_diff() 和 array_filter() 都会创建新数组，这意味着在操作过程中会占用双倍甚至多倍的内存。对于超大型数组，这可能导致内存耗尽。在这种情况下，迭代处理并逐个写入新数组可能更节省内存。

PHP如何从多维数组或嵌套数组中删除特定元素？

从多维数组或嵌套数组中删除元素，就像在俄罗斯套娃里找一个特定的玩具，你得一层一层地剥开。直接操作顶层数组肯定是不行的，你需要遍历到你想要修改的那一层，然后应用我们前面讨论的删除方法。

1. 删除已知路径的元素：

如果元素的位置是固定的，或者你知道它的确切“路径”，那么直接通过多层键名访问并 unset() 即可。

$config = [
    'database' => [
        'host' => 'localhost',
        'user' => 'root',
        'password' => 'secret',
        'port' => 3306
    ],
    'cache' => [
        'driver' => 'redis',
        'ttl' => 3600
    ]
];

// 删除数据库配置中的密码
unset($config['database']['password']);
print_r($config);

我的思考： 这种方式最简单直接，但前提是你

今天关于《PHP删除数组元素的几种方法》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！