有没有一种简单的方法可以使用 PHP 从数组中删除一个元素,从而使 foreach ($array)
不再包含该元素?
我认为将它设置为 null
会做到这一点,但显然它不起作用。
unset()
时,数组上的迭代将不再包含已移除的值。 OTOH,Stevan 的回答确实很充足,而且实际上是我一直在寻找的答案——但不是 OP :)
删除数组元素有多种方法,其中有些方法对某些特定任务比其他方法更有用。
删除单个数组元素
如果您只想删除一个数组元素,您可以使用 unset()
或 \array_splice()
。
如果您知道值并且不知道删除元素的键,您可以使用 \array_search()
来获取键。这仅在元素不多次出现时才有效,因为 \array_search
仅返回第一次命中。
未设置()
请注意,当您使用 unset()
时,数组键不会改变。如果要重新索引键,可以在 unset()
之后使用 \array_values()
,这会将所有键转换为从 0 开始的数字枚举键。
代码:
$array = [0 => "a", 1 => "b", 2 => "c"];
unset($array[1]);
// ↑ Key which you want to delete
输出:
[
[0] => a
[2] => c
]
\array_splice() 方法
如果您使用 \array_splice()
,键将自动重新索引,但关联键不会更改 - 而 \array_values()
会将所有键转换为数字键。
\array_splice()
需要 offset,而不是 key,作为第二个参数。
代码:
$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
// ↑ Offset which you want to delete
输出:
[
[0] => a
[1] => c
]
array_splice()
与 unset()
相同,通过引用获取数组。您不会将这些函数的返回值分配回数组。
删除多个数组元素
如果您想删除多个数组元素并且不想多次调用 unset()
或 \array_splice()
,您可以使用函数 \array_diff()
或 \array_diff_key()
,具体取决于您是否知道元素的值或键你想删除。
\array_diff() 方法
如果您知道要删除的数组元素的值,则可以使用 \array_diff()
。与之前的 unset()
一样,它不会更改数组的键。
代码:
$array = [0 => "a", 1 => "b", 2 => "c", 3 => "c"];
$array = \array_diff($array, ["a", "c"]);
// └────────┘
// Array values which you want to delete
输出:
[
[1] => b
]
\array_diff_key() 方法
如果您知道要删除的元素的键,那么您想使用 \array_diff_key()
。您必须确保将键作为第二个参数中的键而不是值传递。键不会重新索引。
代码:
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
// ↑ ↑
// Array keys which you want to delete
输出:
[
[1] => b
]
如果您想使用 unset()
或 \array_splice()
删除具有相同值的多个元素,您可以使用 \array_keys()
获取特定值的所有键,然后删除所有元素。
\array_filter() 方法
如果要删除数组中具有特定值的所有元素,可以使用 \array_filter()
。
代码:
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_filter($array, static function ($element) {
return $element !== "b";
// ↑
// Array value which you want to delete
});
输出:
[
[0] => a
[1] => c
]
应该注意的是,unset()
将保持索引不变,这是您在使用字符串索引(数组作为哈希表)时所期望的,但在处理整数索引数组时可能会非常令人惊讶:
$array = array(0, 1, 2, 3);
unset($array[2]);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[3]=>
int(3)
} */
$array = array(0, 1, 2, 3);
array_splice($array, 2, 1);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[2]=>
int(3)
} */
因此,如果您想规范化整数键,可以使用 array_splice()
。另一种选择是在 unset()
之后使用 array_values()
:
$array = array(0, 1, 2, 3);
unset($array[2]);
$array = array_values($array);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[2]=>
int(3)
} */
array_splice
有意义的地方(除其他外)。
// Our initial array
$arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red");
print_r($arr);
// Remove the elements who's values are yellow or red
$arr = array_diff($arr, array("yellow", "red"));
print_r($arr);
这是上面代码的输出:
Array
(
[0] => blue
[1] => green
[2] => red
[3] => yellow
[4] => green
[5] => orange
[6] => yellow
[7] => indigo
[8] => red
)
Array
(
[0] => blue
[1] => green
[4] => green
[5] => orange
[7] => indigo
)
现在,array_values() 将很好地重新索引一个数字数组,但它会从数组中删除所有键字符串并用数字替换它们。如果您需要保留键名(字符串),或者如果所有键都是数字的,则重新索引数组,请使用 array_merge():
$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);
输出
Array
(
[0] => blue
[1] => green
[2] => green
[3] => orange
[4] => indigo
)
$key = array_search($needle, $array);
if ($key !== false) {
unset($array[$key]);
}
unset($array[$index]);
此外,对于命名元素:
unset($array["elementName"]);
$a = array("A"=>1, "B"=>2, "C"=>"a");
print_r($a);
unset($a["B"]);
print_r($a);
给出(格式化):Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
unset()
!如果您想改进该建议,则应该编辑该答案。这个多标签页上有太多多余的内容了!
如果您有一个数字索引数组,其中所有值都是唯一的(或者它们是非唯一的,但您希望删除特定值的所有实例),您可以简单地使用 array_diff() 删除匹配的元素,如下所示:
$my_array = array_diff($my_array, array('Value_to_remove'));
例如:
$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);
这将显示以下内容:
4
3
在此示例中,删除了值为“Charles”的元素,这可以通过 sizeof() 调用来验证,该调用报告初始数组的大小为 4,删除后为 3。
销毁数组的单个元素
unset()
$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);
输出将是:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[3]=>
string(1) "D"
[4]=>
string(1) "E"
}
如果需要重新索引数组:
$array1 = array_values($array1);
var_dump($array1);
然后输出将是:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
从数组末尾弹出元素 - 返回已删除元素的值
mixed array_pop(array &$array)
$stack = array("orange", "banana", "apple", "raspberry");
$last_fruit = array_pop($stack);
print_r($stack);
print_r('Last Fruit:'.$last_fruit); // Last element of the array
输出将是
Array
(
[0] => orange
[1] => banana
[2] => apple
)
Last Fruit: raspberry
从数组中移除第一个元素(红色), - 返回移除元素的值
mixed array_shift ( array &$array )
$color = array("a" => "red", "b" => "green" , "c" => "blue");
$first_color = array_shift($color);
print_r ($color);
print_r ('First Color: '.$first_color);
输出将是:
Array
(
[b] => green
[c] => blue
)
First Color: red
array_shift
如果它是整数,则重新索引关键项目,所以它很糟糕,所以你可以使用这个:stackoverflow.com/a/52826684/1407491
array_shift()
的复杂度为 O(n)(由于重新索引数字索引),而 array_pop()
的复杂度为 O(1)。如何知道第一个元素的索引?只需在第一次迭代中启动 foreach
和 break
即可。
<?php
$stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
输出:
[
[0] => fruit2
[1] => fruit3
[2] => fruit4
]
fruit1
array_shift
只能删除数组中的第一个元素。同样使用 array_pop
删除数组中的最后一个元素。
如果指定了索引:
$arr = ['a', 'b', 'c'];
$index = 0;
unset($arr[$index]); // $arr = ['b', 'c']
如果我们有值而不是索引:
$arr = ['a', 'b', 'c'];
// search the value to find index
// Notice! this will only find the first occurrence of value
$index = array_search('a', $arr);
if($index !== false){
unset($arr[$index]); // $arr = ['b', 'c']
}
if
条件是必要的,因为如果找不到 index
,unset()
将自动删除数组的第一个元素,这不是我们想要的。
unset()
早在几年前就已在此页面上多次推荐。 array_search()
和 unset()
早在 2011 年就得到了演示。stackoverflow.com/a/8135667/2943403这个答案没有给这个页面增加新的价值。
如果您必须删除数组中的多个值并且该数组中的条目是对象或结构化数据,那么 array_filter()
是您的最佳选择。从回调函数返回 true 的那些条目将被保留。
$array = [
['x'=>1,'y'=>2,'z'=>3],
['x'=>2,'y'=>4,'z'=>6],
['x'=>3,'y'=>6,'z'=>9]
];
$results = array_filter($array, function($value) {
return $value['x'] > 2;
}); //=> [['x'=>3,'y'=>6,z=>'9']]
如果需要从关联数组中删除多个元素,可以使用 array_diff_key()(此处与 array_flip() 一起使用):
$my_array = array(
"key1" => "value 1",
"key2" => "value 2",
"key3" => "value 3",
"key4" => "value 4",
"key5" => "value 5",
);
$to_remove = array("key2", "key4");
$result = array_diff_key($my_array, array_flip($to_remove));
print_r($result);
输出:
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
关联数组
对于关联数组,使用 unset
:
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
数值数组
对于数值数组,使用 array_splice
:
$arr = array(1, 2, 3);
array_splice($arr, 1, 1);
// RESULT: array(0 => 1, 1 => 3)
笔记
对数值数组使用 unset
不会产生错误,但会弄乱您的索引:
$arr = array(1, 2, 3);
unset($arr[1]);
// RESULT: array(0 => 1, 2 => 3)
unset()
销毁指定的变量。
函数内部 unset()
的行为可能因您尝试销毁的变量类型而异。
如果全局变量是函数内部的 unset()
,则只有局部变量被销毁。调用环境中的变量将保留与调用 unset()
之前相同的值。
<?php
function destroy_foo()
{
global $foo;
unset($foo);
}
$foo = 'bar';
destroy_foo();
echo $foo;
?>
上面代码的答案是吧。
unset()
函数内的全局变量:
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar = "something";
foo();
?>
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
array_search()
没有找到目标值,那么它的 false
返回值将有效地删除 [0]
键控元素,这不是预期的并且会损坏输入数据。我会敦促研究人员不要使用这个片段。
解决方案:
要删除一个元素,请使用 unset():
未设置($数组[3]);未设置($array['foo']);
要删除多个不连续的元素,也可以使用 unset():
未设置($array[3],$array[5]); unset($array['foo'], $array['bar']);
要删除多个连续元素,请使用 array_splice():
array_splice($array, $offset, $length);
进一步说明:
使用这些函数会从 PHP 中删除对这些元素的所有引用。如果您想在数组中保留一个键,但具有一个空值,请将空字符串分配给该元素:
$array[3] = $array['foo'] = '';
除了语法之外,使用 unset() 和将 '' 分配给元素之间存在逻辑差异。第一个说This doesn't exist anymore,
,第二个说This still exists, but its value is the empty string.
如果您正在处理数字,分配 0 可能是更好的选择。因此,如果一家公司停止生产 XL1000 型链轮,它将更新其库存:
unset($products['XL1000']);
但是,如果它暂时用完 XL1000 链轮,但计划在本周晚些时候从工厂接收新的货物,这样会更好:
$products['XL1000'] = 0;
如果您unset() 一个元素,PHP 会调整数组以使循环仍然正常工作。它不会压缩阵列以填充缺失的孔。这就是我们所说的所有数组都是关联的,即使它们看起来是数字的。这是一个例子:
// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
print $animals[1]; // Prints 'bee'
print $animals[2]; // Prints 'cat'
count($animals); // Returns 6
// unset()
unset($animals[1]); // Removes element $animals[1] = 'bee'
print $animals[1]; // Prints '' and throws an E_NOTICE error
print $animals[2]; // Still prints 'cat'
count($animals); // Returns 5, even though $array[5] is 'fox'
// Add a new element
$animals[ ] = 'gnu'; // Add a new element (not Unix)
print $animals[1]; // Prints '', still empty
print $animals[6]; // Prints 'gnu', this is where 'gnu' ended up
count($animals); // Returns 6
// Assign ''
$animals[2] = ''; // Zero out value
print $animals[2]; // Prints ''
count($animals); // Returns 6, count does not decrease
要将数组压缩成一个密集填充的数值数组,请使用 array_values():
$animals = array_values($animals);
或者,array_splice() 自动重新索引数组以避免留下漏洞:
// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
array_splice($animals, 2, 2);
print_r($animals);
Array
(
[0] => ant
[1] => bee
[2] => elk
[3] => fox
)
如果您将数组用作队列并希望从队列中删除项目同时仍允许随机访问,这将非常有用。要安全地删除数组中的第一个或最后一个元素,请分别使用 array_shift() 和 array_pop()。
遵循默认功能:
PHP:未设置
unset()
销毁指定的变量。有关详细信息,您可以参考 PHP unset
$Array = array("test1", "test2", "test3", "test3");
unset($Array[2]);
PHP:数组弹出
array_pop()
函数删除数组的最后一个元素。有关详细信息,您可以参考 PHP array_pop
$Array = array("test1", "test2", "test3", "test3");
array_pop($Array);
PHP: 数组拼接
array_splice()
函数从数组中删除选定元素并用新元素替换它。有关详细信息,您可以参考 PHP array_splice
$Array = array("test1", "test2", "test3", "test3");
array_splice($Array,1,2);
PHP: 数组移位
array_shift()
函数从数组中删除第一个元素。有关详细信息,您可以参考 PHP array_shift
$Array = array("test1", "test2", "test3", "test3");
array_shift($Array);
我只想说我有一个具有可变属性的特定对象(它基本上是映射一个表,我正在更改表中的列,所以对象中的属性,反映表也会有所不同):
class obj {
protected $fields = array('field1','field2');
protected $field1 = array();
protected $field2 = array();
protected loadfields(){}
// This will load the $field1 and $field2 with rows of data for the column they describe
protected function clearFields($num){
foreach($fields as $field) {
unset($this->$field[$num]);
// This did not work the line below worked
unset($this->{$field}[$num]); // You have to resolve $field first using {}
}
}
}
$fields
的全部目的只是,所以当它们被更改时,我不必在代码中到处查看,我只需查看类的开头并更改属性列表和 $fields 数组内容以反映新属性。
假设您有以下数组:
Array
(
[user_id] => 193
[storage] => 5
)
要删除 storage
,请执行以下操作:
unset($attributes['storage']);
$attributes = array_filter($attributes);
你得到:
Array
(
[user_id] => 193
)
array_filter
是做什么用的?
array_filter()
在您的演示中绝对没有意义。
unset()
早在几年前就被推荐了。这个答案没有给这个规范页面增加新的价值。
在保持索引顺序以及不知道第一项的键名的情况下,有两种方法可以删除数组的第一项。
解决方案#1
// 1 is the index of the first object to get
// NULL to get everything until the end
// true to preserve keys
$array = array_slice($array, 1, null, true);
解决方案#2
// Rewinds the array's internal pointer to the first element
// and returns the value of the first array element.
$value = reset($array);
// Returns the index element of the current array position
$key = key($array);
unset($array[$key]);
对于此示例数据:
$array = array(10 => "a", 20 => "b", 30 => "c");
你必须有这个结果:
array(2) {
[20]=>
string(1) "b"
[30]=>
string(1) "c"
}
array_slice()
和 unset()
已经演示了很多次。这个答案是多余的,只会损害研究人员的经验。
unset() 数组中的多个碎片元素
虽然这里多次提到 unset()
,但还没有提到 unset()
接受多个变量,从而可以轻松地在一次操作中从数组中删除多个不连续的元素:
// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]
unset() 动态
unset() 不接受要删除的键数组,因此下面的代码将失败(尽管动态使用 unset() 会稍微容易一些)。
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
相反, unset() 可以在 foreach 循环中动态使用:
$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]
通过复制数组删除数组键
还有另一种做法尚未提及。有时,摆脱某些数组键的最简单方法是简单地将 $array1 复制到 $array2 中。
$array1 = range(1,10);
foreach ($array1 as $v) {
// Remove all even integers from the array
if( $v % 2 ) {
$array2[] = $v;
}
}
print_r($array2);
// Output: [ 1, 3, 5, 7, 9 ];
显然,同样的做法适用于文本字符串:
$array1 = [ 'foo', '_bar', 'baz' ];
foreach ($array1 as $v) {
// Remove all strings beginning with underscore
if( strpos($v,'_')===false ) {
$array2[] = $v;
}
}
print_r($array2);
// Output: [ 'foo', 'baz' ]
根据键删除数组元素:
使用如下 unset
函数:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
根据值删除数组元素:
使用 array_search
函数获取元素键并使用上述方式删除数组元素,如下所示:
$a = array(
'salam',
'10',
1
);
$key = array_search(10, $a);
if ($key !== false) {
unset($a[$key]);
}
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
unset()
和 array_search()
与 unset()
已于 2017 年发布。此答案仅提供多余的见解。
编辑
如果您不能认为该对象在该数组中,则需要添加一个检查:
if(in_array($object,$array)) unset($array[array_search($object,$array)]);
原始答案
如果您想通过引用该对象来删除数组的特定对象,您可以执行以下操作:
unset($array[array_search($object,$array)]);
例子:
<?php
class Foo
{
public $id;
public $name;
}
$foo1 = new Foo();
$foo1->id = 1;
$foo1->name = 'Name1';
$foo2 = new Foo();
$foo2->id = 2;
$foo2->name = 'Name2';
$foo3 = new Foo();
$foo3->id = 3;
$foo3->name = 'Name3';
$array = array($foo1,$foo2,$foo3);
unset($array[array_search($foo2,$array)]);
echo '<pre>';
var_dump($array);
echo '</pre>';
?>
结果:
array(2) {
[0]=>
object(Foo)#1 (2) {
["id"]=>
int(1)
["name"]=>
string(5) "Name1"
}
[2]=>
object(Foo)#3 (2) {
["id"]=>
int(3)
["name"]=>
string(5) "Name3"
}
}
请注意,如果对象多次出现,则只会在第一次出现时将其删除!
array_search()
未找到目标数组键,则其返回值将有效地破坏 [0]
键元素。此代码段很危险,应删除。早期的答案没有犯这个错误。
in_array()
对阵列进行潜在的全面扫描,然后使用 array_search()
再次进行潜在的全面扫描,这绝对不是我向任何人推荐的事情。这简直是不好的做法。我的立场仍然是——这个答案犯了以前的答案没有犯的错误。更正此答案只会使其与之前的答案无关。如果删除此答案,此页面将得到改进。
使用以下代码:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
array_pop($arr)
即可删除最后的条目。不需要` = `。
<?php
// If you want to remove a particular array element use this method
$my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
print_r($my_array);
if (array_key_exists("key1", $my_array)) {
unset($my_array['key1']);
print_r($my_array);
}
else {
echo "Key does not exist";
}
?>
<?php
//To remove first array element
$my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
print_r($my_array);
$new_array = array_slice($my_array, 1);
print_r($new_array);
?>
<?php
echo "<br/> ";
// To remove first array element to length
// starts from first and remove two element
$my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
print_r($my_array);
$new_array = array_slice($my_array, 1, 2);
print_r($new_array);
?>
输出
Array ( [key1] => value 1 [key2] => value 2 [key3] =>
value 3 ) Array ( [key2] => value 2 [key3] => value 3 )
Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
Array ( [key2] => value 2 [key3] => value 3 )
Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
Array ( [key2] => value 2 [key3] => value 3 )
unset()
之前检查密钥是否存在是没有好处的。如果在数组中找不到键,则 unset()
将不做任何事情(如预期的那样)。在发布此答案之前,已经推荐了 unset()
和 array_slice()
。这个答案没有给这个页面增加新的价值。
我来到这里是因为我想看看是否有比使用 unset($arr[$i]) 更优雅的解决方案来解决这个问题。令我失望的是,这些答案要么是错误的,要么没有涵盖所有边缘情况。
这就是为什么 array_diff() 不起作用的原因。键在数组中是唯一的,而元素并不总是唯一的。
$arr = [1,2,2,3];
foreach($arr as $i => $n){
$b = array_diff($arr,[$n]);
echo "\n".json_encode($b);
}
结果...
[2,2,3]
[1,3]
[1,2,2]
如果两个元素相同,它们将被删除。这也适用于 array_search() 和 array_flip()。
我看到了很多关于 array_slice() 和 array_splice() 的答案,但这些函数只适用于数值数组。如果这里没有回答问题,我知道的所有答案,所以这里有一个可行的解决方案。
$arr = [1,2,3];
foreach($arr as $i => $n){
$b = array_merge(array_slice($arr,0,$i),array_slice($arr,$i+1));
echo "\n".json_encode($b);
}
Results...
[2,3];
[1,3];
[1,2];
由于 unset($arr[$i]) 将适用于关联数组和数值数组,这仍然不能回答这个问题。
此解决方案是比较键并使用可以处理数字和关联数组的工具。我为此使用 array_diff_uassoc() 。此函数比较回调函数中的键。
$arr = [1,2,2,3];
//$arr = ['a'=>'z','b'=>'y','c'=>'x','d'=>'w'];
foreach($arr as $key => $n){
$b = array_diff_uassoc($arr, [$key=>$n], function($a,$b) {
if($a != $b){
return 1;
}
});
echo "\n".json_encode($b);
}
结果.....
[2,2,3];
[1,2,3];
[1,2,2];
['b'=>'y','c'=>'x','d'=>'w'];
['a'=>'z','c'=>'x','d'=>'w'];
['a'=>'z','b'=>'y','d'=>'w'];
['a'=>'z','b'=>'y','c'=>'x'];
不定期副业成功案例分享
$x = array(1, 2, 3, 4);
unset($x[2])
结果 必须 为var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }
时,您不可能拥有array (3) { [0]=>int(0) ...
(可能是错字)unset
可以有多个参数:void unset ( mixed $var [, mixed $... ] )
。unset
不是函数,而是语言结构(和关键字)。它不能也不能以 `` 为前缀