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

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

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

Следует отметить, что 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 = 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 = 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]); } с $key = array_search($needle,$array); if($key!==false){ unset($array[$key]); } 

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

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

unset($array["elementName"]);

 <?php $stack = array("fruit1", "fruit2", "fruit3", "fruit4"); $fruit = array_shift($stack); print_r($stack); echo $fruit; ?> 

Вывод:

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

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

unset()

 $array1 = array('A', 'B', 'C', 'D', 'E'); unset($array1[2]); // Delete known index(2) value from array var_dump($array1); с $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_diff :

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

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

unset() уничтожает указанные переменные.

Поведение unset() внутри функции может варьироваться в зависимости от того, какой тип переменной вы пытаетесь уничтожить.

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

 <?php function destroy_foo() { global $foo; unset($foo); } $foo = 'bar'; destroy_foo(); echo $foo; ?> с <?php function destroy_foo() { global $foo; unset($foo); } $foo = 'bar'; destroy_foo(); echo $foo; ?> 

Ответ на этот код будет баром

Чтобы unset() глобальную переменную внутри функции

 <?php function foo() { unset($GLOBALS['bar']); } $bar = "something"; foo(); ?> не <?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) с $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) с $arr = array(1, 2, 3); unset($arr[1]); // RESULT : array(0 => 1, 2 => 3) 

Если вам нужно удалить несколько значений в массиве, а записи в этом массиве – объекты или структурированные данные, [array_filter][1] – ваш лучший [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 */ public function removeFromArr($arr, $val) { unset($arr[array_search($val, $arr)]); return array_values($arr); } 

Выполнение функций по умолчанию

 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); с 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); 

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

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

Чтобы удалить storage , выполните следующие действия:

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

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

 Array ( [user_id] => 193 ) 

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

Я просто хотел бы сказать, что у меня есть определенный 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 {} } } } с 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 {} } } } с 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, чтобы отразить новые атрибуты.

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

 <?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); ?> с <?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 как unset ниже:

 $a = array( 'salam', '10', 1 ); unset( $a[1] ); print_r( $a ); /* Output: Array ( [0] => salam [2] => 1 ) */ 

Удалите элемент массива на основе значения:

Используйте функцию array_search для получения ключа элемента и используйте вышеприведенный способ удаления элемента массива, как 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, а затем, где я положил элемент, который вы хотите удалить, вы помещаете что-то вроде: «a». И если вы хотите удалить несколько, то: «a», «b».

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

Здесь более простой способ удаления с помощью foreach и unset.

 $array=[1,2,4,7,5,6]; foreach ($array as $key=>$value) { if($value==$id)unset($array[$key]); } print($array); 

Результат: Массив ([0] => 1 [2] => 4 [3] => 7 [4] => 5 [5] => 6) Элемент 2 удален.

Это может помочь …

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

Для тех из вас, кто ищет hash#delete ruby hash#delete эквивалент в php:

 <?php function array_delete(&$array, $key) { if (!isset($array[$key])) { return null; } $value = $array[$key]; unset($array[$key]); return $value; } с <?php function array_delete(&$array, $key) { if (!isset($array[$key])) { return null; } $value = $array[$key]; unset($array[$key]); return $value; } 

Добавляю, потому что это было так, как я попал сюда в первый раз …

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

 $anArray = array("X", "Y", "Z"); unset($anArray[0]); //'dumps' the content of $anArray to the page: var_dump($anArray); с $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" } 

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

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