在PHP中从一个数组中删除一个元素

有没有一种简单的方法可以用PHP从数组中删除一个元素，从而使foreach ($array)不再包括该元素？

我以为把它设置为null就可以了，但显然它不起作用了。

有不同的方法来删除一个数组元素，其中有些方法对于某些特定的任务比其他方法更有用。

删除一个单一的数组元素

如果你想只删除一个数组元素，你可以使用unset()或者\array_splice()来删除。

如果你知道值而不知道删除元素的键，你可以使用\array_search()来获得键。这只在该元素不出现多次的情况下有效，因为\array_search只返回第一次命中。

unset()

注意，当你使用unset()时，数组的键不会改变。如果你想对键值进行重新索引，你可以在unset()之后使用\array_values()，这将把所有键值转换为从0开始的数字枚举键。

代码：C

$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，作为第二个参数。

代码：C

$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()一样，它不会改变数组的键。

代码：C

$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()。你必须确保你在第二个参数中把键作为键传递，而不是作为值。键值不会重新索引。

代码：C

$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()。

代码：C

$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()将保持索引不变，这是在使用字符串索引（数组为hashtable）时你所期望的，但在处理整数索引数组时，可能会相当令人惊讶。

$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)
} */

  // 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]);

如果你有一个数字索引数组，所有的值都是唯一的（或者它们是非唯一的，但你希望删除一个特定值的所有实例），你可以简单地使用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($array["elementName"]);

销毁一个数组中的单个元素

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

<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

输出。

[
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
]

fruit1

如果指定了索引，那么就会出现。

$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()将自动删除数组的第一个元素，这不是我们想要的结果。

如果你必须删除一个数组中的多个值，并且该数组中的条目是对象或结构化数据，那么array_filter()是你最好的选择。那些从回调函数返回真值的条目将被保留。

$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;
?>

上述代码的答案将是bar。

为了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);
}

解决办法。

1. 要删除一个元素，使用unset()。

unset($array[3]);
unset($array['foo']);

2. 要删除多个不连续的元素，也可以使用unset()。

unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);

3. 要删除多个连续的元素，请使用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(阵列)

该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
)

在保持索引顺序的情况下，以及在不知道第一个项目的键名的情况下，有两种方法可以删除数组的第一个项目。

解决方案#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"
}

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' ]

<?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函数，如下图所示。

$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
        )

*/

编辑部

如果你不能认为该对象在该数组中，你就需要添加一个检查。

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"
    }
}

请注意，如果该对象出现了几次，它将只在第一次出现时被删除。

使用下面的代码。

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);

我来到这里是因为我想看看是否有比使用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'];

第一步，先从php合成器开始。

<?php

第二步

创建一个名为 "动物 "的数组

<?php 
$animals= array(
  
    'cat', // [0]
    'dog', // [1]
    'cow' // [2]
  
);

第3步

删除索引1的项目，该项目是 "for"。

unset($animals1[1]); 

第4步

打印修改后的数组

var_dump($danimals1);

第5步

重新索引数组中的元素

$newarray = array_values($animals1);
  

第6步

打印重新索引过的数组

var_dump($newarray);

第7步

关闭php代码

?>