Удаление элемента из массива в PHP
https://stackoverflow.com/questions/369602
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Есть ли простой способ удалить элемент из массива с помощью PHP, например, foreach ($array) больше не включает этот элемент?
Я думал, что установив это на null сделал бы это, но видимо это не работает.
Решение
Существуют разные способы удаления элемента массива, некоторые из которых более полезны для некоторых конкретных задач, чем другие.
Удалить один элемент массива
Если вы хотите удалить только один элемент массива, вы можете использовать \unset() или альтернативно \array_splice().
Также, если у вас есть значение и вы не знаете ключ для удаления элемента, вы можете использовать \array_search() чтобы получить ключ.
\unset() метод
Обратите внимание, что когда вы используете \unset() ключи массива не будут меняться/переиндексироваться.Если вы хотите переиндексировать ключи, вы можете использовать \array_values() после \unset() который преобразует все ключи в числовые ключи, начиная с 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() чтобы получить все ключи для определенного значения, а затем удалить все элементы.
Другие советы
Необходимо отметить, что 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)
} */
// 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
В этом примере элемент со значением «Чарльз» удаляется, что можно проверить с помощью вызовов 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 = array("fruit1", "fruit2", "fruit3", "fruit4");
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Выход:
Array
(
[0] => fruit2
[1] => fruit3
[2] => fruit4
)
fruit1
Чтобы избежать поиска, можно поиграть с array_diff:
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
В этом случае не нужно искать/использовать ключ.
Если вам нужно удалить несколько значений в массиве, а записи в этом массиве являются объектами или структурированными данными, [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']]
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();
?>
Ассоциативные массивы
Для ассоциативных массивов используйте 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)
Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать 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 )
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
Предположим, у вас есть следующий массив:
Array
(
[user_id] => 193
[storage] => 5
)
Удалить storage, делать:
unset($attributes['storage']);
$attributes = array_filter($attributes);
И вы получаете:
Array
(
[user_id] => 193
)
Я просто хотел бы сказать, что у меня был конкретный объект с переменными атрибутами (по сути, это было сопоставление таблицы, и я менял столбцы в таблице, поэтому атрибуты в объекте, отражающие таблицу, также будут различаться):
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 было просто, поэтому мне не нужно искать повсюду в коде, когда они изменяются, я просто просматриваю начало класса и меняю список атрибутов и $поля содержимое массива для отражения новых атрибутов.
Следуйте функциям по умолчанию:
я)
$Array = array("test1", "test2", "test3", "test3");
unset($Array[2]);
2)
$Array = array("test1", "test2", "test3", "test3");
array_pop($Array);
3)
$Array = array("test1", "test2", "test3", "test3");
array_splice($Array,1,2);
iv)
$Array = array("test1", "test2", "test3", "test3");
array_shift($Array);
Решения:
- Чтобы удалить один элемент, используйте сбросить():
unset($array[3]); unset($array['foo']);
- Чтобы удалить несколько несмежных элементов, также используйте сбросить():
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
- Чтобы удалить несколько смежных элементов, используйте array_splice():
array_splice($array, $offset, $length);
Дальнейшее объяснение:
Использование этих функций удаляет все ссылки на эти элементы из PHP.Если вы хотите сохранить ключ в массиве, но с пустым значением, присвойте элементу пустую строку:
$array[3] = $array['foo'] = '';
Помимо синтаксиса, существует логическая разница между использованием сбросить() и присвоение '' элементу.Первый говорит 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 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(), соответственно.
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
)
*/
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
Создайте свой массив в переменной $array а затем там, где я поставил «элемент, который вы хотите удалить», вы поместили что-то вроде:"а".И если вы хотите удалить несколько элементов, то:«а», «б».
Используйте следующий код:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
Два способа удаления первого элемента массива с сохранением порядка индекса, а также если вы не знаете имя ключа первого элемента.
Решение №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_search, чтобы получить ключ и удалить его, если он найден:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
Для ассоциативных массивов с нецелочисленными ключами:
Просто, unset($array[$key]) должно сработать.
Для массивов, имеющих целочисленные ключи, и если вы хотите сохранить свои ключи:
$array = [ 'mango', 'red', 'orange', 'grapes'];unset($array[2]); $array = array_values($array);array_splice($array, 2, 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 )
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
);
print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);
print_r($arrayName);
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 )
