Удаление элемента из массива в PHP

avatar
Ben
15 декабря 2008 в 20:28
3201711
26
2846

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

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

Источник
brandizzi
26 июля 2012 в 17:05
16

Я бы не сказал, что ответ Конрада самый простой на поставленную задачу. С unset() итерации по массиву больше не будут включать удаленное значение. OTOH, это правда, что ответ Стевана достаточен, и, на самом деле, это был ответ, который я искал, но не ОП :)

Dan Nissenbaum
11 февраля 2014 в 05:18
40

@danip То, что его легко найти в руководстве, не исключает вопроса о StackOverflow. Если бы вопрос был дублированным вопросом StackOverflow, то он мог бы быть здесь неуместен. StackOverflow — это хорошее место, где можно найти ответы в качестве варианта, даже до того, как вы заглянете в руководство.

trojan
4 сентября 2014 в 12:55
6

@unset ($ массив [$ ключ]); $массив = массив_значений($массив);

Legolas
23 сентября 2015 в 08:18
0

Связанный вопрос об удалении этого в цикле foreach: coderhelper.com/questions/1949259/…

Somnath Muluk
26 декабря 2017 в 13:10
1

Если вы хотите удалить ключи из массива массива (ассоциативный массив), см. решение на coderhelper.com/a/47978980/1045444.

Aurangzeb
25 июня 2019 в 10:50
2

вы можете сделать это в цикле foreach следующим образом: pastefs.com/pid/130950

blakroku
20 ноября 2019 в 07:05
1

Установка значения ключа массива в значение null простыми средствами включает в себя ключ, который имеет значение null. Ключ все еще существует.

Jose Manuel Abarca Rodríguez
20 января 2021 в 16:40
0

@Aurangzeb, код работает отлично (должен быть ответ, и я бы проголосовал за его простоту).

Ответы (26)

avatar
Rizier123
13 октября 2020 в 16:36
3292

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

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

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

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

unset()

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

Код:

$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() в качестве второго параметра требуется смещение, а не ключ.

Код:

$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(), он не изменит ключи массива.

Код:

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

Код:

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

Alexandru R
13 июня 2012 в 12:23
0

если у вас есть <?php $x = array(1, 2, 3, 4); сбросить ($ х [2]); var_dump($х); // array(3) { [0]=> int(0), [1]=> int(2), [3]=> int(4), } ?>

Konrad Rudolph
13 июня 2012 в 12:26
29

@AlexandruRada Нет, ты сказал «не используй это» — и это просто ерунда. Вы можете безопасно использовать этот метод, когда вы относитесь к массиву как к словарю. Только если вы ожидаете последовательные числовые индексы, вам нужно использовать что-то еще.

inemanja
19 апреля 2016 в 05:33
1

@AlexandruRada У вас не может быть array (3) { [0]=>int(0) ..., когда вы unset($x[2]) из $x = array(1, 2, 3, 4); Результат должен быть var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) } (вероятно, это была опечатка)

Константин Ван
14 апреля 2017 в 03:12
9

unset может иметь несколько аргументов: void unset ( mixed $var [, mixed $... ] ).

dotnetCarpenter
6 мая 2017 в 00:20
4

array_filter также является жизнеспособным методом. Особенно хорошо, если вы не хотите изменять массив, но он также не переиндексирует, что может быть проблемой с json_encode. php.net/manual/en/function.json-encode.php#94157

Nabi K.A.Z.
16 октября 2018 в 01:23
0

В array_splice и других кодах необходимо знать имя ключа или значения массива, поэтому некоторое время переиндексируйте массив ключей, чтобы удалить первый элемент с сохранением порядка индекса, и если элемент индекса неизвестен, можно использовать этот метод: coderhelper. com/a/52826684/1407491

Kuldeep singh
11 июля 2019 в 06:27
0

Есть ли способ удалить элемент массива из многомерного (ключ, значение) массива.

Moisés Márquez
23 июля 2019 в 15:47
0

Для удаления нескольких элементов или проверки многомерных массивов может быть полезным дополнением array_map.

hvertous
3 декабря 2019 в 14:19
1

unset — это не функция, а языковая конструкция (и ключевое слово). Он не должен и не может иметь префикс ``

Konrad Rudolph
26 февраля 2020 в 10:29
0

@ShivamSharma Я откатил ваше редактирование — array_values уже упоминалось, и ваше редактирование, таким образом, существенно удлиняло и без того длинный ответ без добавления новой информации.

Konrad Rudolph
7 июля 2020 в 19:11
0

@АртемНосов Пожалуйста, не удаляйте обратную косую черту, они там не просто так.

Jed Lynch
13 октября 2020 в 14:34
0

Этот ответ неверен. Ключи в массиве по определению имеют уникальное ограничение, а элементы — нет. Такие функции, как array_flip() и array_search(), не дадут вам правильных результатов, если несколько одинаковых элементов.

Konrad Rudolph
13 октября 2020 в 16:30
0

@JedLynch Ответ уже касается этого случая (в частности, последнего абзаца). Но я сделал пример более понятным, а также удалил ссылку на array_flip, что, я согласен, здесь неуместно.

Samuel Silas
14 июля 2021 в 15:47
1

@КонстантинВан попал в точку

vanowm
28 ноября 2021 в 22:19
0

Что за обратная косая черта перед именами функций?

Konrad Rudolph
28 ноября 2021 в 22:59
0

@vanowm php.net/manual/en/language.namespaces.basics.php

avatar
Jed Lynch
13 октября 2020 в 14:32
0

Я пришел сюда, потому что хотел посмотреть, есть ли более элегантное решение этой проблемы, чем использование 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'];
avatar
Sam Tigle
11 июня 2019 в 10:16
5

Изменить

Если вы не можете считать, что объект находится в этом массиве, вам нужно добавить проверку:

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

Обратите внимание, что если объект встречается несколько раз, он будет удален только при первом появлении!

mickmackusa
22 августа 2021 в 03:00
0

Этот ответ не является стабильным. Если целевой ключ массива не найден с помощью array_search(), то его возвращаемое значение эффективно уничтожит элемент с ключом [0]. Этот фрагмент опасен и должен быть удален. Были более ранние ответы, которые не делают этой ошибки.

Sam Tigle
24 августа 2021 в 10:08
0

@micmackusa спасибо за подсказку, добавил чек

mickmackusa
24 августа 2021 в 10:27
0

Выполнение потенциально полного сканирования массива с помощью in_array(), а затем еще одного потенциально полного сканирования с помощью array_search() — это определенно не то, что я бы рекомендовал никому. Это просто плохая практика. Моя позиция остается неизменной - этот ответ делает ошибки, которых не было в предыдущих ответах. Исправление этого ответа сделает его излишним по сравнению с предыдущими ответами. Эта страница будет улучшена, если этот ответ будет удален.

avatar
Ahmad Mobaraki
23 мая 2019 в 12:26
28

Если указан индекс:

$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() автоматически удалит первый элемент массива, который нам не нужен.

mickmackusa
22 августа 2021 в 02:46
0

unset() уже неоднократно рекомендовался на этой странице много лет назад. array_search() с unset() было продемонстрировано еще в 2011 году. coderhelper.com/a/8135667/2943403 Этот ответ не добавляет новой ценности этой странице.

Ahmad Mobaraki
22 августа 2021 в 03:34
0

@micmackusa, возможно, вы правы, всю информацию в этом ответе можно найти в других ответах. но, возможно, наличие всего этого в одном ответе для разных условий и простое объяснение сэкономит кому-то время. так что это можно рассматривать как ценность, я думаю!

mickmackusa
22 августа 2021 в 03:37
0

Это один из способов увидеть это. Другой способ увидеть эту страницу с несколькими вкладками — «сильно раздутый излишними советами». Исследователи просматривают одни и те же советы снова и снова, чтобы убедиться, что они учитывают все соответствующие советы. Поскольку ответы представляют собой смесь одного и нескольких методов, И многие ответы говорят об одном и том же, опыт исследователя очень сильно пострадал. Представьте, если бы вам понадобился совет с этой страницы. Хотели бы вы прочитать роман, полный ненужных советов? Я бы не стал.

mickmackusa
22 августа 2021 в 03:38
0

Если вы лично нашли предыдущие ответы «неясными» или требующими более подробной информации, вы можете отредактировать эти ответы, чтобы лучше помочь исследователям, вместо того, чтобы публиковать новый ответ. Это означает, что лучшие советы распределяются по меньшему количеству ответов.

Ahmad Mobaraki
22 августа 2021 в 03:50
0

Я согласен с вами во многих случаях. Но я думаю, что целью редактирования ответа является исправление некоторых слов или незначительных технических опечаток, а не его расширение / изменение. В любом случае, я сам потратил некоторое время, чтобы просмотреть все ответы и найти простой и эффективный способ сделать это, и придумал это решение, и я подумал, что, возможно, это хорошая идея, чтобы поделиться им. Я думаю, что причина, по которой он получает некоторые голоса, заключается в том, что у других людей такая же ситуация, и они находят этот ответ простым, понятным и исчерпывающим! @микмакуса

mickmackusa
22 августа 2021 в 04:00
0

Проблема с обращением внимания только на подсчет голосов заключается в том, что он не регистрирует бесчисленное количество людей, которые отказались от чтения других ответов из-за «усталости читателя». Упаковывая избыточную информацию в большее количество ответов, новому ответу с уникальными идеями становится все труднее быть замеченным/прочитанным. Уделите некоторое внимание новым / появляющимся ответам, которые на самом деле содержат уникальные советы (опубликованные и еще не опубликованные). If the index is NOT specified: на самом деле должно говорить If the value is specified: -- тогда следует говорить, что удаляется только первое вхождение.

Ahmad Mobaraki
22 августа 2021 в 04:13
0

@micmackusa Спасибо, обязательно сделаю. Причина, по которой мне нравится продолжать это обсуждение, заключается в том, что мне не все равно, и я не публиковал этот ответ два года назад только для того, чтобы получить голоса. Я редко публикую ответы! Я помню, когда я, наконец, нашел то, что хотел на этой странице (хотя в то время я был новичком!): 1- просто uset() 2- мы должны сначала найти индекс, если у нас его нет. 3- почему нам нужно использовать условие if, а не просто передавать array_search в unset()? Я чувствовал, что нашел окончательный правильный и полный ответ:)))))

avatar
Jens Erat
19 февраля 2019 в 10:55
6

Используйте следующий код:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
Krista K
16 сентября 2014 в 00:33
5

php5: простой запуск array_pop($arr) удаляет последнюю запись. `=` не требуется.

avatar
Nabi K.A.Z.
16 октября 2018 в 01:20
9

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

Решение №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"
}
mickmackusa
22 августа 2021 в 02:54
2

array_slice() и unset() уже демонстрировались много раз, прежде чем вы опубликовали свой ответ. Этот ответ является излишним и только вредит опыту исследователя.

Nabi K.A.Z.
23 августа 2021 в 05:35
0

@micmackusa Но мой ответ был чистым и ясным.

mickmackusa
23 августа 2021 в 05:54
1

...и лишнее. Вы не добавили на эту страницу уникальное значение, относящееся к удалению элемента. Вы отошли от темы, чтобы поговорить о том, как настроить таргетинг на ключ первого элемента. OP не упоминает о желании нацелиться на первый элемент. Вы, вероятно, были обмануты в другой области, читая другие ответы на этой очень переполненной странице. Этот ответ безопасно удален ради улучшения опыта исследователя.

avatar
Star
29 января 2018 в 11:08
13

Решения:

  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;

Если вы 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() соответственно.

avatar
Kristoffer Bohmann
7 декабря 2017 в 06:28
8

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()).

$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' ]
avatar
MahdiY
22 сентября 2017 в 10:28
7

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

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

*/
mickmackusa
22 августа 2021 в 02:56
1

unset() и array_search() с unset() уже были опубликованы к 2017 году. Этот ответ дает только избыточную информацию.

avatar
UMAR FAROOQUE KHAN
16 августа 2016 в 15:36
6
<?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 )
mickmackusa
22 августа 2021 в 02:57
0

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

avatar
Simon
20 апреля 2016 в 21:05
22

Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать 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 ) 
Fr0zenFyr
2 декабря 2016 в 08:13
0

Почему это так недооценено?

mickmackusa
22 августа 2021 в 02:47
1

Потому что исследователи изо всех сил пытаются использовать страницу, которая чрезмерно раздута излишними ответами. На этой канонической странице очень сильно испорчен "опыт исследователя".

avatar
GigolNet Guigolachvili
2 апреля 2016 в 18:42
19
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}
mickmackusa
22 августа 2021 в 02:44
0

Этот ответ только для кода нестабилен. Если целевое значение не найдено с помощью array_search(), то его возвращаемое значение false эффективно удалит элемент с ключом [0], который не предназначен и повреждает входные данные. Я призываю исследователей не использовать этот фрагмент.

avatar
John Slegers
11 марта 2016 в 18:48
22

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

Для ассоциативных массивов используйте 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)
avatar
spyle
18 февраля 2016 в 01:40
25

Если вам нужно удалить несколько значений в массиве, а записи в этом массиве являются объектами или структурированными данными, лучше всего подойдет 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']]
avatar
msvairam
25 января 2016 в 13:07
11

Используйте функции по умолчанию:

  • PHP: отключено

unset() уничтожает указанные переменные. Для получения дополнительной информации вы можете обратиться к PHP unset

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

unset($Array[2]);
  • PHP: array_pop

Функция 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

Функция array_shift() удаляет первый элемент из массива. Для получения дополнительной информации вы можете обратиться к PHP array_shift

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

array_shift($Array);
avatar
KTAnj
19 июля 2015 в 15:37
38

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

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
Nabi K.A.Z.
16 октября 2018 в 01:31
1

array_shift переиндексирует ключевые элементы, если он целочисленный, так что это плохо, поэтому вы можете использовать это: coderhelper.com/a/52826684/1407491

AmigoJack
23 октября 2021 в 13:00
0

Сложность array_shift() составляет O(n) (из-за переиндексации числовых индексов), а для array_pop() это O(1). Как узнать индекс первого элемента? Просто запустите foreach и break прямо в первой итерации.

avatar
Tebe
11 июня 2015 в 22:25
9

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

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

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

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

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

Array
(
    [user_id] => 193
)
David
17 марта 2017 в 14:38
0

Для чего используется array_filter?

Tebe
26 июня 2017 в 12:13
0

удалить ложные элементы

mickmackusa
22 августа 2021 в 00:27
0

тогда array_filter() абсолютно бессмысленно в вашей демонстрации.

mickmackusa
22 августа 2021 в 02:50
0

unset() был рекомендован несколько лет назад. Этот ответ не добавляет новой ценности этой канонической странице.

avatar
Oxydel
21 августа 2013 в 02:31
10

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

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 содержимое массива для отражения новых атрибутов.

avatar
Ankit Aggarwal
26 июля 2013 в 20:11
21

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();
?>
avatar
Saurabh Chandra Patel
11 июня 2013 в 05:51
37
<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Вывод:

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

fruit1
Jasir KT
22 июля 2014 в 17:22
15

Обратите внимание, что array_shift может удалить только первый элемент массива. аналогичным образом используйте array_pop, чтобы удалить последний элемент в массиве.

sweisgerber.dev
14 октября 2014 в 11:03
3

Ответ применим только к первому элементу массива и не отвечает на общий вопрос.

Saurabh Chandra Patel
14 октября 2014 в 12:13
0

@sebweisgerber вы правы, но я не думаю, что это неправильно, и мне нужно понизить этот ответ. Вопрос заключается в удалении элемента без упоминания какой-либо позиции.

Jed Lynch
13 октября 2020 в 14:39
1

Это охватывает только один пограничный случай

mickmackusa
23 августа 2021 в 00:24
0

Этот метод не имеет высокой степени полезности, как упоминалось ранее. В этом ответе отсутствует образовательное объяснение.

avatar
Robin Nixon
26 ноября 2012 в 08:25
70

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

Jed Lynch
13 октября 2020 в 14:39
0

Если два элемента имеют одинаковое значение, это не сработает.

avatar
liamvictor
15 ноября 2011 в 11:29
225
$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}
ToolmakerSteve
24 сентября 2016 в 18:09
7

Было бы хорошо уточнить, что этот ответ предназначен для удаления элемента, когда вы знаете значение, но не ключ. Обратите внимание, что он удаляет только ПЕРВЫЙ экземпляр значения; чтобы найти все ключи для значения, используйте array_keys

Jed Lynch
13 октября 2020 в 14:38
0

Если несколько элементов имеют одинаковое значение, это не сработает.

avatar
Marcel Cozma
2 августа 2011 в 15:57
401
  // 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
)
heart hacker
20 сентября 2018 в 05:56
0

$get_merged_values ​​= array_merge($data['res'],$data['check_res']); когда я печатаю это print_r($get_merged_values); он отображает следующее. Массив ( [0] => Массив ( [код_меню] => 2 [имя_меню] => Завод [номер_порядка_меню] => 1 ) [1] => Массив ( [код_меню] => 3 [имя_меню] => Номер строки [номер_заказа] => 2 )) Но мне нужно получить значения menu_code и menu_name, используя $get_merged_values['menu_code'] и $get_merged_values['menu_name'] соответственно, вместо использования $get_merged_values[0][menu_code], $get_merged_values[0 ][имя_меню]. пожалуйста, помогите мне, как это сделать?

Jed Lynch
13 октября 2020 в 14:38
0

Формулировка вопроса вводит в заблуждение из того, как он сформулирован. Это не сработает, если вы хотите удалить $arr[$i] в цикле foreach, если несколько элементов имеют одинаковое значение.

avatar
DefenestrationDay
31 июля 2010 в 01:06
69

Также для именованного элемента:

unset($array["elementName"]);
DefenestrationDay
9 июня 2011 в 01:50
0

$a = array("A"=>1, "B"=>2, "C"=>"a"); print_r($a); unset($a["B"]); print_r($a); дает (отформатировано): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )

carpii
6 апреля 2012 в 00:29
0

Кажется, вы не можете сбросить элементы массива, индексированные строкой (генерирует «Неустранимая ошибка: невозможно сбросить смещения строки»). Я не думаю, что так было всегда, но определенно с PHP 5.3.10 и, возможно, раньше.

Jimbo
20 марта 2013 в 09:56
7

@carpii PHP может удалять элементы из ассоциативного массива. Неустранимая ошибка возникает, когда вы пытаетесь использовать unset($var['key']) для строки вместо массива. Например: $array = array('test' => 'value', 'another' => ' ценность', ); сбросить ($ массив ['тест']); // Удаляет элемент "test" из массива, как и ожидалось $array = 'test'; сбросить ($ массив ['тест']); // Выдает "Неустранимая ошибка: Невозможно отменить смещения строк", как и ожидалось

Nabi K.A.Z.
16 октября 2018 в 01:23
0

Здесь вы должны знать имя ключа, это лучше: coderhelper.com/a/52826684/1407491

mickmackusa
23 августа 2021 в 00:22
0

@Eran уже рекомендовал unset() еще в 2008 году! Если вы хотели улучшить этот совет, вы должны были отредактировать этот ответ. На этой странице с несколькими вкладками слишком много лишнего контента!

avatar
Stefan Gehrig
15 декабря 2008 в 21:25
1392

Следует отметить, что 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)
} */
Tom
8 июня 2012 в 21:57
47

Стоит отметить, что когда вы используете array_splice(), вам нужно знать OFFSET, а не ключ, а смещение (!) любого элемента, который вы хотите удалить.

Stefan Gehrig
9 июня 2012 в 12:18
20

@Tom: для обычного массива (с непрерывной целочисленной индексацией) смещение — это индекс. Вот где array_splice может иметь смысл (среди прочего).

Tom
9 июня 2012 в 16:12
5

Да, конечно, но просто кое-что, что нужно помнить, если вы вмешиваетесь в массив перед использованием сплайсинга.

Cyril N.
17 ноября 2014 в 16:21
1

Остается один вопрос (и было бы здорово получить ответ здесь): какой из них лучше с точки зрения производительности?

Doug Kavendek
1 декабря 2014 в 17:01
4

Из простого теста на удаление тонны элементов из гигантского массива array_splice кажется намного быстрее и требует меньше памяти. Это соответствует тому, что я ожидал: кажется, что array_values() делает копию массива, а array_splice работает на месте.

Rorrik
2 июня 2015 в 16:38
4

array_values ​​— полезный подход, когда вы удаляете элементы в цикле и хотите, чтобы индексы были согласованными, но затем хотите сжать их после цикла.

Pmpr
20 июля 2016 в 12:38
0

Я думаю, что образец массива был выбран не с умом, так как ключи равны значениям

Javier Larroulet
28 сентября 2018 в 16:55
1

имеет смысл, что array_splice быстрее или эффективнее, поскольку он использует смещение, а не индекс, чтобы «выбрать» удаляемые элементы. Обход на основе смещений, а не индексов избавляет вас от чтения индекса каждого элемента.

Jed Lynch
13 октября 2020 в 14:35
0

Array_splice будет работать только для числовых массивов, поэтому array_slice — не лучший ответ.

avatar
Eran Galperin
15 декабря 2008 в 20:31
100
unset($array[$index]);