有没有一种简单的方法可以使用PHP从数组中删除元素，以便foreach ($array)不再包含该元素？
我认为将其设置为null会这样做，但显然它不起作用。
答案 0 :(得分：2553)
有多种方法可以删除数组元素，其中某些元素对某些特定任务比其他元素更有用。
如果您只想删除一个数组元素，可以使用\unset()或\array_splice()。
此外，如果您拥有该值并且不知道删除该元素的键，则可以使用\array_search()来获取该密钥。
\unset()方法请注意，使用\unset()时，数组键不会更改/重新索引。如果要重新索引键，可以在\unset()之后使用\array_values()，这会将所有键转换为从0开始的数字枚举键。
代码
<?php
$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()需要偏移，而不是密钥！作为第二个参数。
代码
<?php
$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()一样，它不会改变/重新索引数组的键。
代码
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff($array, ["a", "c"]);
//└────────┘→ Array values which you want to delete
?>
输出
[
[1] => b
]
\array_diff_key()方法如果您知道要删除的元素的键，则需要使用\array_diff_key()。在这里，您必须确保将键作为键传递给第二个参数而不是值。否则，您必须使用\array_flip()翻转数组。而且这里的密钥不会改变/重新索引。
代码
<?php
$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()获取特定值的所有键，然后删除所有元素
答案 1 :(得分：1330)
应该注意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()。另一种选择是在array_values()之后使用unset()：
$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)
} */
答案 2 :(得分：349)
// 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
)
答案 3 :(得分：188)
$key = array_search($needle, $array);
if ($key !== false) {
unset($array[$key]);
}
答案 4 :(得分：73)
unset($array[$index]);
答案 5 :(得分：61)
如果你有一个数字索引数组，其中所有值都是唯一的（或者它们是非唯一的，但你希望删除特定值的所有实例），你可以简单地使用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。
答案 6 :(得分：57)
另外，对于命名元素：
unset($array["elementName"]);
答案 7 :(得分：29)
销毁数组的单个元素
<强> 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
答案 8 :(得分：26)
<?php
$stack = array("fruit1", "fruit2", "fruit3", "fruit4");
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
输出：
Array
(
[0] => fruit2
[1] => fruit3
[2] => fruit4
)
fruit1
答案 9 :(得分：25)
为了避免进行搜索，可以使用array_diff：
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
在这种情况下，不必搜索/使用密钥。
答案 10 :(得分：17)
unset()销毁指定的变量。
函数内部unset()的行为可能会因您尝试销毁的变量类型而异。
如果函数内部的全局变量为unset()，则仅销毁本地变量。调用环境中的变量将保留与调用unset()之前相同的值。
<?php
function destroy_foo()
{
global $foo;
unset($foo);
}
$foo = 'bar';
destroy_foo();
echo $foo;
?>
以上代码的答案为 bar 。
unset()函数内的全局变量：
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar = "something";
foo();
?>
答案 11 :(得分：17)
如果您必须删除数组中的多个值，并且该数组中的条目是对象或结构化数据，[array_filter][1]是您最好的选择。将保留那些从回调函数返回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']]
答案 12 :(得分：17)
对于关联数组，请使用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)
答案 13 :(得分：16)
如果您需要从关联数组中删除多个元素，可以使用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 )
答案 14 :(得分：15)
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
答案 15 :(得分：7)
假设您有以下数组：
Array
(
[user_id] => 193
[storage] => 5
)
要删除storage，请执行：
unset($attributes['storage']);
$attributes = array_filter($attributes);
你得到：
Array
(
[user_id] => 193
)
答案 16 :(得分：7)
遵循默认功能：
i）个
$Array = array("test1", "test2", "test3", "test3");
unset($Array[2]);
ⅱ）
$Array = array("test1", "test2", "test3", "test3");
array_pop($Array);
ⅲ）
$Array = array("test1", "test2", "test3", "test3");
array_splice($Array,1,2);
IV）
$Array = array("test1", "test2", "test3", "test3");
array_shift($Array);
答案 17 :(得分：7)
<强>解决方案：
unset($array[3]); unset($array['foo']);
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
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()。
答案 18 :(得分：7)
我只想说我有一个具有变量属性的特定对象（它基本上映射了一个表而我正在更改表中的列，因此反映表的对象中的属性也会有所不同）：
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 数组内容以反映新属性。
答案 19 :(得分：5)
虽然这里已多次提到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（）稍微容易一些）。
$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' ]
答案 20 :(得分：5)
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
在变量$array中创建数组，然后在我要放置的元素中删除＆＃39;你写了类似的东西：＆＃34; a＆＃34;。如果你想删除多个项目，那么：＆＃34; a＆＃34;，＆＃34; b＆＃34;。
答案 21 :(得分：5)
使用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
)
*/
答案 22 :(得分：5)
<?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 )
答案 23 :(得分：4)
使用以下代码：
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
答案 24 :(得分：4)
通过两种方法删除数组的第一项，同时保持索引的顺序，如果您不知道第一项的键名，也可以这样做。
// 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);
// 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"
}
答案 25 :(得分：3)
使用array_search获取密钥，并在未设置的情况下将其删除：
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
答案 26 :(得分：3)
对于关联数组，使用非整数键：
简单地说，unset($array[$key])可行。
对于具有整数键的数组以及如果要维护键：
$array = [ 'mango', 'red', 'orange', 'grapes'];
unset($array[2]);
$array = array_values($array);
array_splice($array, 2, 1);
答案 27 :(得分：1)
我来到这里是因为我想看看是否有比使用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'];
答案 28 :(得分：1)
这可能会有所帮助......
<?php
$a1 = array("a"=>"red", "b"=>"green", "c"=>"blue", "d"=>"yellow");
$a2 = array("a"=>"purple", "b"=>"orange");
array_splice($a1, 0, 2, $a2);
print_r($a1);
?>
结果将是：
Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )
答案 29 :(得分：0)
$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // Here is the key to be deleted
echo '<br>';
array_values($x);
var_dump($x);
答案 30 :(得分：0)
unset不会更改索引，但array_splice会更改：
$arrayName = array('1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
500 => 'somevalue500',
);
echo $arrayName['500'];
//somevalue500
array_splice($arrayName, 1, 2);
print_r($arrayName);
//Array ( [0] => somevalue [1] => somevalue500 )
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
500 => 'somevalue500',
);
echo $arrayName['500'];
//somevalue500
unset($arrayName[1]);
print_r($arrayName);
//Array ( [0] => somevalue [1] => somevalue500 )
答案 31 :(得分：0)
如果您知道索引：
$arr = ['a', 'b', 'c'];
$index = 0;
unset($arr[$index]); // result: $arr = ['b', 'c']
如果您不知道索引，则必须先搜索值：
$arr = ['a', 'b', 'c'];
$index = array_search('a',$arr);
unset($arr[$index]); // result: $arr = ['b', 'c']
答案 32 :(得分：0)
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
);
print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);
print_r($arrayName);
答案 33 :(得分：0)
如果要通过引用删除数组的特定对象，可以执行以下操作：
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"
}
}
请注意，如果对象多次出现，则只会在第一次出现时将其删除！
答案 34 :(得分：0)
使用unset删除密钥Street：
<?php
$arr1 = array("Name" => "Johm", "Street" => "Waall", "Country" => "India");
unset($arr1["Street"]);
?>
结果：
array("Name" => "Johm","Country" => "India")`
这将不会在删除值后重新索引数组，因此请使用array_splice();
答案 35 :(得分：-1)
执行此任务有两种方法：取消设置（）和 array_splice（）
让我们假设两个数组：
$array_1 = array('a'=>'One', 'b'=>'Two', 'c'=>'Three');
$array_2 = array('Red', 'Yellow', 'White', 'Black', 'Green');
使用unset（）
syntax - unset(array_element)
unset($array_1['a']); // Any valid key
unset($array_2[0]); // Any valid index
使用array_splice（）
syntax - array_splice(array, index, length)
array_splice($array_1, 1, 1); // Remove one element from $array_1 from index 1
array_splice($array_2, 3, 1); // Remove one element from $array_2 from index 3
答案 36 :(得分：-1)
您只需使用unset()删除数组。
请记住，必须在foreach函数后取消设置数组。
答案 37 :(得分：-3)
您可以使用 array_pop 方法删除数组的最后一个元素：
<?php
$a = array("one", "two", "Three");
array_pop($a);
print_r($a);
?>
The out put will be
Array ( [0] => one[1] => two)
答案 38 :(得分：-3)
我们可以使用foreach使用参考来修改变量内容：
<?php
// Remove all elements in the array
foreach ($array as &$arr) {
$arr = null;
}
答案 39 :(得分：-3)
对于那些在PHP中寻找Ruby hash#delete等价物的人：
<?php
function array_delete(&$array, $key) {
if (!isset($array[$key])) {
return null;
}
$value = $array[$key];
unset($array[$key]);
return $value;
}
这不仅会删除数组中的元素，还会返回存储在该键中的值，以便您以非线性方式使用数组。