PHP: удалить элемент из массива

Есть ли простой способ удалить элемент из массива с помощью PHP, так что foreach ($array) больше не включает этот элемент?

Я думал, что установить его в null будет делать это, но, видимо, это не сработает.

2014
задан Ben 15 дек. '08 в 23:28
источник поделиться
33 ответов
  • 1
  • 2

Существуют различные способы удаления элемента массива, где некоторые из них более полезны для некоторых конкретных задач, чем другие.

Удалить один элемент массива

Если вы хотите удалить только один элемент массива, вы можете использовать unset() или альтернативный array_splice().

Также, если у вас есть значение и вы не знаете ключа для удаления элемента, вы можете использовать array_search() чтобы получить ключ.

метод unset()

Обратите внимание, что при использовании unset() ключи массива не будут меняться/переиндексироваться. Если вы хотите переиндексировать ключи, вы можете использовать array_values() после unset() который преобразует все ключи в числовые перечисляемые ключи, начиная с 0.

Код

<?php

    $array = array(0 => "a", 1 => "b", 2 => "c");
    unset($array[1]);
               //↑ Key which you want to delete

?>

Вывод

Array (
    [0] => a
    [2] => c
)

array_splice()

Если вы используете array_splice() ключи будут автоматически переиндексированы, но ассоциативные ключи не будут меняться в отличие от array_values() которые преобразуют все ключи в числовые ключи.

Кроме того, array_splice() требует смещения, а не ключа! как второй параметр.

Код

<?php

    $array = array(0 => "a", 1 => "b", 2 => "c");
    array_splice($array, 1, 1);
                       //↑ Offset which you want to delete

?>

Вывод

Array (
    [0] => a
    [1] => c
)

array_splice() как unset() принимает массив по ссылке, это означает, что вы не хотите назначать возвращаемые значения этих функций обратно в массив.

Удаление нескольких элементов массива

Если вы хотите удалить несколько элементов массива и не хотите вызывать unset() или array_splice() несколько раз, вы можете использовать функции array_diff() или array_diff_key() зависимости от того, знаете ли вы значения или ключи элементов, которые вы хотите удалить.

array_diff()

Если вам известны значения элементов массива, которые вы хотите удалить, вы можете использовать array_diff(). Как и раньше, с unset() он не будет изменять/переиндексировать ключи массива.

Код

<?php

    $array = array(0 => "a", 1 => "b", 2 => "c");
    $array = array_diff($array, ["a", "c"]);
                              //└────────┘→ Array values which you want to delete

?>

Вывод

Array (
    [1] => b
)

array_diff_key()

Если вам известны ключи элементов, которые вы хотите удалить, вы хотите использовать array_diff_key(). Здесь вы должны убедиться, что вы передаете ключи как ключи во втором параметре, а не как значения. В противном случае вам нужно перевернуть массив с помощью array_flip(). А также здесь ключи не изменятся/переиндексируются.

Код

<?php

    $array = array(0 => "a", 1 => "b", 2 => "c");
    $array = array_diff_key($array, [0 => "xy", "2" => "xy"]);
                                   //↑           ↑ Array keys which you want to delete
?>

Вывод

Array (
    [1] => b
)

Также, если вы хотите использовать unset() или array_splice() для удаления нескольких элементов с тем же значением, вы можете использовать array_keys() чтобы получить все ключи для определенного значения, а затем удалить все элементы.

2286
ответ дан Konrad Rudolph 15 дек. '08 в 23:30
источник поделиться

Следует отметить, что 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() можно использовать, если вы хотите нормализовать свои целые ключи. Другой вариант - 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)
} */
1305
ответ дан Stefan Gehrig 16 дек. '08 в 0:25
источник поделиться
  // our initial array  
   $arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red");  
  print_r($arr);

  // remove the elements who 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
)
323
ответ дан Marcel Cozma 02 авг. '11 в 18:57
источник поделиться
$key = array_search($needle,$array);
if($key!==false){
    unset($array[$key]);
}
177
ответ дан liamvictor 15 нояб. '11 в 14:29
источник поделиться
unset($array[$index]);
61
ответ дан Eran Galperin 15 дек. '08 в 23:31
источник поделиться

Если у вас есть числовой индексный массив, где все значения уникальны (или они не являются уникальными, но вы хотите удалить все экземпляры определенного значения), вы можете просто использовать 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

В этом примере элемент со значением "Чарльз" удаляется, как это можно проверить с помощью вызовов sizeof(), которые сообщают размер 4 для исходного массива и 3 после удаления.

57
ответ дан Robin Nixon 26 нояб. '12 в 11:25
источник поделиться

Кроме того, для именованного элемента:

unset($array["elementName"]);

50
ответ дан DefenestrationDay 31 июля '10 в 4:06
источник поделиться

Уничтожить один элемент массива

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
27
ответ дан KTAnj 19 июля '15 в 18:37
источник поделиться
<?php
    $stack = array("fruit1", "fruit2", "fruit3", "fruit4");
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Выход:

Array
(
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
)

fruit1
23
ответ дан Saurabh Chandra Patel 11 июня '13 в 8:51
источник поделиться

Чтобы избежать выполнения поиска, вы можете играть с array_diff:

$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11

В этом случае вам не нужно искать/использовать ключ.

21
ответ дан Mugoma J. Okomba 22 сент. '16 в 7:01
источник поделиться

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();
?>
14
ответ дан Ankit Aggarwal 26 июля '13 в 23:11
источник поделиться

Ассоциативные массивы

Для ассоциативных массивов используйте 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)
14
ответ дан John Slegers 11 марта '16 в 21:48
источник поделиться

Если вам нужно удалить несколько значений в массиве, а записи в этом массиве - объекты или структурированные данные, [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']]
14
ответ дан spyle 18 февр. '16 в 4:40
источник поделиться

Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать 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 ) 
13
ответ дан Simon 21 апр. '16 в 0:05
источник поделиться
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}
11
ответ дан GigolNet Guigolachvili 02 апр. '16 в 21:42
источник поделиться

Предположим, что у вас есть такой массив:

Array
(
    [user_id] => 193
    [storage] => 5
)

Чтобы удалить storage, выполните:

unset($attributes['storage']);
$attributes = array_filter($attributes);

И вы получите:

Array
(
    [user_id] => 193
)
6
ответ дан Tebe 12 июня '15 в 1:25
источник поделиться

Следуйте функциям по умолчанию

i)

$Array = array("test1","test2","test3","test3");

unset($Array[2]);

ii)

$Array = array("test1","test2","test3","test3");

array_pop($Array);

iii)

$Array = array("test1","test2","test3","test3");

array_splice($Array,1,2);

iv)

$Array = array("test1","test2","test3","test3");

array_shift($Array);
6
ответ дан msvairam 25 янв. '16 в 16:07
источник поделиться

Я хотел бы сказать, что у меня есть определенный Object, который имел переменные атрибуты (это было в основном сопоставление таблицы, и я менял столбцы в таблице, поэтому атрибуты в объекте, отражающие таблицу, будут меняться как а

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, чтобы отразить новые атрибуты.

Понадобился немного времени, чтобы понять это. Надеюсь, это поможет кому-то.

6
ответ дан Oxydel 21 авг. '13 в 5:31
источник поделиться

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' ]
4
ответ дан Kristoffer Bohmann 07 дек. '17 в 9:28
источник поделиться
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>

Создайте свой массив в массиве переменных $, а затем, где я положил элемент, который вы хотите удалить, вы помещаете что-то вроде: "a". И если вы хотите удалить несколько, то: "a", "b".

4
ответ дан Joshua Charles Pickwell 23 нояб. '17 в 11:17
источник поделиться
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result= array_pop($arr);
print_r($result);
4
ответ дан Sunil Kumar Sain 17 мая '13 в 11:56
источник поделиться

Решения:

  1. Чтобы удалить один элемент, используйте unset():
unset($array[3]);
unset($array['foo']);
  1. Чтобы удалить несколько несмежных элементов, также используйте unset():
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. Чтобы удалить несколько смежных элементов, используйте 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;

Если вы отключили() элемент, 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 new element
$animals[ ] = 'gnu'; // add 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() соответственно.

3
ответ дан Star 29 янв. '18 в 14:08
источник поделиться
<?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 ) 
2
ответ дан UMAR FAROOQUE KHAN 16 авг. '16 в 18:36
источник поделиться

Удалить элемент массива на основе ключа:

Используйте функцию 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
)

*/
2
ответ дан MahdiY 22 сент. '17 в 13:28
источник поделиться

Для ассоциативных массивов с не целочисленными ключами:

Просто, unset($array[$key]) будет работать.

Для массивов с целыми ключами и если вы хотите сохранить свои ключи:

  1. $array = [ 'mango', 'red', 'orange', 'grapes'];

unset($array[2]); с unset($array[2]); $array = array_values($array);

  1. array_splice($array, 2, 1);
1
ответ дан Akshay Prakash 27 апр. '18 в 11:23
источник поделиться

$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // here is key to be delete
echo '<br>';
array_values($x);
var_dump($x);
0
ответ дан Wakar Ahmad Khan 21 марта '18 в 9:48
источник поделиться

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 )
0
ответ дан inrsaurabh 10 марта '18 в 18:05
источник поделиться

Существует два способа выполнения этой задачи

unset() и 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 1 element from $array_1 from index 1
array_splice($array_2,3,1); // remove 1 element from $array_2 from index 3
  • все элементы массива индексируются после удаления элемента из массива
0
ответ дан Mohammad Wasim 24 апр. '18 в 12:28
источник поделиться

При удалении элемента из массива в PHP хорошей функцией является функция unset. Вот пример его использования:

$anArray = array("X", "Y", "Z");

unset($anArray[0]);

//'dumps' the content of $anArray to the page:
var_dump($anArray);  

Результатом функции var_dump будет:

array(2) { [1]=> string(1) "Y" [2]=> string(1) "Z" }
0
ответ дан Arun Vitto 14 сент. '17 в 11:53
источник поделиться

Вы можете просто использовать unset() для удаления массива.

Помните, что после функции foreach массив должен быть отключен.

0
ответ дан Drake Boein 30 окт. '17 в 20:12
источник поделиться
  • 1
  • 2

Другие вопросы по меткам