Есть ли простой способ удалить элемент из массива с помощью 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()
сохранит индексы нетронутыми, что вы ожидаете при использовании строковых индексов (массив как 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)
} */
array_splice
может иметь смысл (среди прочих).
// 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
)
$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"]);
$a = array("A"=>1, "B"=>2, "C"=>"a");
print_r($a);
unset($a["B"]);
с unset($a["B"]);
print_r($a);
дает (отформатированный): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
Уничтожить один элемент массива
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_diff
:
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
В этом случае вам не нужно искать/использовать ключ.
<?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_shift
может удалить только первый элемент в массиве. аналогично используйте array_pop
для удаления последнего элемента в массиве.
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_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']]
Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать 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 = 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);
Предположим, у вас есть следующий массив:
Array
(
[user_id] => 193
[storage] => 5
)
Чтобы удалить storage
, выполните:
unset($attributes['storage']);
$attributes = array_filter($attributes);
И вы получите:
Array
(
[user_id] => 193
)
array_filter
используется array_filter
?
Я просто хотел бы сказать, что у меня был определенный объект, который имел переменные атрибуты (это было в основном отображение таблицы, и я менял столбцы в таблице, поэтому атрибуты в объекте, отражающие таблицу, также могли бы меняться):
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 для отражения новые атрибуты.
Решения:
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;
Если вы отменили() элемент, 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(), соответственно.
Хотя 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' ]
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
Создайте свой массив в переменной $array
а затем, где я поместил "элемент, который вы хотите удалить", вы поместите что-то вроде: "a". А если вы хотите удалить несколько, то: "a", "b".
Удалить элемент массива на основе ключа:
Используйте функцию 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
//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 )
Используйте следующий код:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
array_pop($arr)
удаляет последнюю запись. Нет `=` необходимо.
Два способа удаления первого элемента массива с сохранением порядка индекса, а также, если вы не знаете имя ключа первого элемента.
// 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 array 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($array[$key])
будет работать.
Для массивов с целыми ключами и если вы хотите сохранить свои ключи:
$array = [ 'mango', 'red', 'orange', 'grapes'];
unset($array[2]);
с unset($array[2]);
$array = array_values($array);
array_splice($array, 2, 1);
$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);
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 )
Это может помочь...
<?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 )
Мы можем изменить содержимое переменной с помощью refenrece, используя foreach
<?php
//Remove all element in the array
foreach ($array as &$arr ) {
$arr = null;
}
foreach ($array)
будет по-прежнему включать элементы, для которых установлено значение null
.
Существует два способа выполнения этой задачи
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
Вы можете просто использовать unset()
для удаления массива.
Помните, что после функции foreach
массив должен быть отключен.
При удалении элемента из массива в 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" }
Для тех из вас, кто ищет ruby hash#delete
эквивалент в php:
<?php
function array_delete(&$array, $key) {
if (!isset($array[$key])) {
return null;
}
$value = $array[$key];
unset($array[$key]);
return $value;
}
Добавляю, потому что это было так, как я попал сюда в первый раз...
Это не только удалит элемент из вашего массива, но также вернет значение, сохраненное в этом ключе, чтобы вы могли потреблять ваш массив нелинейным образом.
Вы можете использовать метод array_pop для удаления последнего элемента массива
<?php
$a=array("one","two","Three");
array_pop($a);
print_r($a);
?>
The out put will be
Array ( [0] => one[1] => two)
unset()
итерации по массиву больше не будут включать удаленное значение. ОТО, это правда, что ответ Стевана достаточно и, на самом деле, был ответ, который я искал - но не ОП :)