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

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

2941
Ben 15 Дек 2008 в 23:28
17
Я бы не стал, чтобы ответ Конрада был самым простым на поставленную проблему. С unset() итерации по массиву больше не будут включать удаленное значение. OTOH, это правда, что Стеван ответил достаточно, и, на самом деле, это был ответ, который я искал, но не OP :)
 – 
brandizzi
26 Июл 2012 в 21:05
44
Легкость поиска в руководстве не исключает вопроса о StackOverflow. Если бы вопрос был повторяющимся вопросом StackOverflow, он мог бы здесь не подходить. StackOverflow - хорошее место, где можно найти ответы еще до того, как заглянуть в руководство.
 – 
Dan Nissenbaum
11 Фев 2014 в 09:18
7
@unset ($ array [$ key]); $ array = array_values ​​($ массив);
 – 
trojan
4 Сен 2014 в 16:55
2
Если вы хотите удалить ключи из массива массива (ассоциативный массив), см. Решение на странице stackoverflow.com/a/47978980/1045444
 – 
Somnath Muluk
26 Дек 2017 в 16:10
2
Вы можете сделать это в цикле foreach следующим образом: pastefs.com/pid/130950
 – 
Aurangzeb
25 Июн 2019 в 13:50

33 ответа

Лучший ответ

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

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

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

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

Метод \array_filter()

Если вы хотите удалить все элементы с определенным значением в массиве, вы можете использовать \array_filter().

Код:

$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_filter($array, static function ($element) {
    return $element !== "b";
    //                   ↑
    // Array value which you want to delete
});

Выход:

[
    [0] => a
    [1] => c
]
3421
20 revs, 12 users 27% 23 Мар 2022 в 17:24
29
Нет, вы сказали «не используйте это» - и это полная чушь. Вы можете безопасно использовать этот метод, когда рассматриваете массив как то, что он есть - словарь. Только если вы ожидаете последовательных числовых индексов, вам нужно использовать что-то еще.
 – 
Konrad Rudolph
13 Июн 2012 в 16:26
1
Невозможно получить 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) } (вероятно, это была опечатка)
 – 
inemanja
19 Апр 2016 в 08:33
9
unset может иметь несколько аргументов: void unset ( mixed $var [, mixed $... ] ).
 – 
Константин Ван
14 Апр 2017 в 06:12
4
Array_filter также является жизнеспособным методом. Особенно хорошо, если вы не хотите изменять массив, но он также не переиндексирует, что может быть проблемой с json_encode. php.net/manual/en/function.json-encode.php# 94157
 – 
dotnetCarpenter
6 Май 2017 в 03:20
2
unset - это не функция, а языковая конструкция (и ключевое слово). Он не должен и не может начинаться с префикса ``
 – 
hvertous
3 Дек 2019 в 17:19

Шаг первый, начните с php syntex

<?php

Шаг второй

Создать массив с именами животных

<?php 
$animals= array(
  
    'cat', // [0]
    'dog', // [1]
    'cow' // [2]
  
);

Шаг третий

Удалить элемент с индексом 1, который предназначен для

unset($animals1[1]); 

Шаг четвертый

Распечатать измененный массив

var_dump($danimals1);

Шаг пятый

Переиндексировать элементы массива

$newarray = array_values($animals1);
  

Шаг шестой

Распечатать переиндексированный массив

var_dump($newarray);

Шаг седьмой

Закрыть php-код

?>
0
Muhammad Ali Shah 27 Сен 2022 в 21:48

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

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

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

28
Mugoma J. Okomba 23 Сен 2016 в 01:10
Это будет работать, только если все элементы уникальны.
 – 
Jed Lynch
13 Окт 2020 в 17:40

Используйте array_search, чтобы получить ключ, и удалите его с неустановленным, если он найден:

if (($key = array_search('word', $array)) !== false) {
    unset($array[$key]);
}
10
user8031209user8031209 24 Фев 2019 в 14:19
<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

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

9
Peter Mortensen 22 Фев 2019 в 13:02

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

Просто unset($array[$key]) подойдет.

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

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

    unset($array[2]);
    $array = array_values($array);
    
  2. array_splice($array, 2, 1);

6
Peter Mortensen 22 Фев 2019 в 13:12
$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);

print_r($arrayName);
3
kyun 29 Май 2019 в 08:33

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

<?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 )
2
Peter Mortensen 22 Фев 2019 в 12:56

Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать 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 ) 
22
Simon 21 Апр 2016 в 00:05
Почему это так недооценивают?
 – 
Fr0zenFyr
2 Дек 2016 в 11:13
1
Потому что исследователи изо всех сил пытаются использовать страницу, переполненную повторяющимися ответами. На этой канонической странице "опыт исследователя" сильно испорчен.
 – 
mickmackusa
22 Авг 2021 в 05:47
  // 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
)
410
Peter Mortensen 19 Фев 2019 в 13:52
$ get_merged_values ​​= array_merge ($ data ['res'], $ data ['check_res']); когда я печатаю этот print_r ($ get_merged_values); он отображает следующее. Массив ([0] => Массив ([menu_code] => 2 [menu_name] => Завод [menu_order_no] => 1) [1] => Массив ([menu_code] => 3 [menu_name] => Строка [menu_order_no] » => 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 ] [имя_меню]. пожалуйста, помогите мне, как это сделать?
 – 
heart hacker
20 Сен 2018 в 08:56
Формулировка вопроса вводит в заблуждение по сравнению с тем, как он сформулирован. Это не сработает, если вы хотите удалить $ arr [$ i] в цикле foreach, если несколько элементов имеют одинаковое значение.
 – 
Jed Lynch
13 Окт 2020 в 17:38
array_merge(array_diff( вы сэкономили мне время, спасибо за оба примера, 1.keys are not re-indexed и another one with keys are indexed again from 0...n
 – 
Mohammed Sufian
19 Авг 2022 в 18:21
$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}
230
Peter Mortensen 19 Фев 2019 в 13:54
7
Было бы хорошо уточнить, что этот ответ предназначен для удаления элемента, когда вы знаете значение, но не ключ. Обратите внимание, что он удаляет только ПЕРВЫЙ экземпляр значения; чтобы найти все ключи для значения, используйте array_keys < / а>
 – 
ToolmakerSteve
24 Сен 2016 в 21:09
Если несколько элементов имеют одинаковое значение, это не сработает.
 – 
Jed Lynch
13 Окт 2020 в 17:38
unset($array[$index]);
101
Eran Galperin 15 Дек 2008 в 23:31

Если у вас есть массив с числовым индексом, в котором все значения уникальны (или они не уникальны, но вы хотите удалить все экземпляры определенного значения), вы можете просто использовать array_diff () для удаления соответствующего элемента, например:

$my_array = array_diff($my_array, array('Value_to_remove'));

Например:

$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);

Это отображает следующее:

4
3

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

70
Robin Nixon 26 Ноя 2012 в 12:25
Если два элемента имеют одинаковое значение, это не сработает.
 – 
Jed Lynch
13 Окт 2020 в 17:39

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

unset($array["elementName"]);
71
Mohammad 13 Ноя 2018 в 14:05
$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 )
 – 
DefenestrationDay
9 Июн 2011 в 05:50
Кажется, вы не можете сбросить элементы массива, проиндексированные строкой (генерирует «Неустранимая ошибка: невозможно сбросить смещения строки»). Я не думаю, что так было всегда, но, конечно, начиная с PHP 5.3.10 и, возможно, раньше
 – 
carpii
6 Апр 2012 в 04:29
7
PHP может удалять элементы из ассоциативного массива. Фатальная ошибка возникает, когда вы пытаетесь использовать unset ($ var ['key']) в строке вместо массива. Например: $ array = array ('test' => 'value', 'another' => ' ценить', ); unset ($ array ['test']); // Удаляет элемент "test" из массива, как ожидалось $ array = 'test'; unset ($ array ['test']); // Выдает сообщение «Неустранимая ошибка: невозможно отменить смещение строки», как ожидалось
 – 
Jimbo
20 Мар 2013 в 13:56
Уже рекомендовал unset() еще в 2008 году! Если вы хотите улучшить этот совет, вам следовало отредактировать этот ответ. На этой странице с несколькими вкладками слишком много избыточного контента!
 – 
mickmackusa
23 Авг 2021 в 03:22

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

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
38
Peter Mortensen 25 Май 2016 в 21:16
1
array_shift повторно индексирует ключевые элементы, если это целое число, значит, это плохо, поэтому вы можете использовать это: stackoverflow.com/a / 52826684/1407491
 – 
Nabi K.A.Z.
16 Окт 2018 в 04:31
Сложность array_shift() составляет O (n) (из-за повторной индексации числовых индексов) а для array_pop() это O (1). Как узнать индекс первого элемента? Просто запустите foreach и break прямо на первой итерации.
 – 
AmigoJack
23 Окт 2021 в 16:00
<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Выход:

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

fruit1
37
Neha Sharma 3 Сен 2019 в 05:54
15
Обратите внимание, что array_shift может удалить только первый элемент в массиве. аналогично используйте array_pop для удаления последнего элемента в массиве.
 – 
Jasir
22 Июл 2014 в 21:22
3
Ответ применим только к первому элементу массива и не отвечает на общий вопрос.
 – 
sweisgerber.dev
14 Окт 2014 в 15:03
Вы правы, но я не думаю, что это неправильно, и мне нужно проголосовать против этого ответа. Вопрос в том, чтобы удалить элемент, не упоминающий ни одной позиции.
 – 
Saurabh Chandra Patel
14 Окт 2014 в 16:13
1
Это покрывает только один крайний случай
 – 
Jed Lynch
13 Окт 2020 в 17:39
Как упоминалось ранее, этот метод не обладает высокой степенью полезности. В этом ответе отсутствует образовательное объяснение.
 – 
mickmackusa
23 Авг 2021 в 03:24

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

Для ассоциативных массивов используйте 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)
22
Peter Mortensen 22 Фев 2019 в 12:51

Следует отметить, что 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)
} */
1407
Ry- 13 Янв 2012 в 21:32
49
Стоит отметить, что когда вы используете array_splice (), вам нужно знать OFFSET, а не ключ, а смещение (!) Любого элемента, который вы хотите удалить.
 – 
Tom
9 Июн 2012 в 01:57
20
@Tom: для обычного массива (с непрерывным целочисленным индексом) смещение - это индекс. Вот где array_splice может иметь смысл (среди прочего).
 – 
Stefan Gehrig
9 Июн 2012 в 16:18
5
Да, конечно, но просто кое-что нужно запомнить, если вы вмешаетесь в массив перед использованием сплайсинга.
 – 
Tom
9 Июн 2012 в 20:12
4
После простого теста на удаление тонны элементов из гигантского массива array_splice кажется намного быстрее и требует меньше памяти. Это соответствует тому, что я ожидал: похоже, что array_values ​​() создает копию массива, а array_splice работает на месте.
 – 
Doug Kavendek
1 Дек 2014 в 20:01
4
Array_values ​​- полезный подход, когда вы удаляете элементы в цикле и хотите, чтобы индексы были согласованными, но затем хотите сжать их после цикла.
 – 
Rorrik
2 Июн 2015 в 19:38
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}
19
Gigoland 30 Июл 2018 в 15:54
Этот ответ, состоящий только из кода, нестабилен. Если целевое значение не найдено array_search(), то его возвращаемое значение false эффективно удалит ключевой элемент [0], который не предназначен и наносит ущерб входным данным. Я призываю исследователей не использовать этот фрагмент.
 – 
mickmackusa
22 Авг 2021 в 05:44

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

  • 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);
11
Rabby 16 Окт 2020 в 15:34

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

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

10
Peter Mortensen 19 Фев 2019 в 13:59

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

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

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

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

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

Array
(
    [user_id] => 193
)
9
Abdur Rehman 14 Фев 2019 в 09:15
Для чего используется array_filter?
 – 
David
17 Мар 2017 в 17:38
Удалить фальшивые элементы
 – 
Tebe
26 Июн 2017 в 15:13
Тогда array_filter() абсолютно бессмысленен в вашей демонстрации.
 – 
mickmackusa
22 Авг 2021 в 03:27
unset() был рекомендован годами ранее. Этот ответ не добавляет новой ценности этой канонической странице.
 – 
mickmackusa
22 Авг 2021 в 05:50

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

Решение # 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"
}
9
Peter Mortensen 22 Фев 2019 в 13:14
2
array_slice() и unset() уже были продемонстрированы много раз, прежде чем вы опубликовали свой ответ. Этот ответ является избыточным и только портит опыт исследователя.
 – 
mickmackusa
22 Авг 2021 в 05:54
Но мой ответ был чистым и ясным.
 – 
Nabi K.A.Z.
23 Авг 2021 в 08:35
1
... и лишний. Вы не добавили на эту страницу никакого уникального значения, специфичного для удаления элемента. Вы ушли не по теме, чтобы поговорить о том, как настроить таргетинг на ключ первого элемента. OP не упоминает о желании настроить таргетинг на первый элемент. Вы, вероятно, попали в другую область, прочитав другие ответы на этой переполненной странице. Этот ответ благополучно удален для улучшения опыта исследователя.
 – 
mickmackusa
23 Авг 2021 в 08:54

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' ]
8
Abdur Rehman 14 Фев 2019 в 09:14

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

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

*/
7
Peter Mortensen 22 Фев 2019 в 13:01
1
unset() и array_search() с unset() уже были опубликованы к 2017 году. Этот ответ дает только избыточную информацию.
 – 
mickmackusa
22 Авг 2021 в 05:56

Редактировать

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

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

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

7
Sam Tigle 24 Авг 2021 в 13:07
Этот ответ нестабилен. Если целевой ключ массива не найден array_search(), то его возвращаемое значение фактически уничтожит ключевой элемент [0]. Этот фрагмент опасен и должен быть удален. Существовали более ранние ответы, в которых не было этой ошибки.
 – 
mickmackusa
22 Авг 2021 в 06:00
Спасибо за подсказку, добавил чек
 – 
Sam Tigle
24 Авг 2021 в 13:08
Я бы никому не рекомендовал выполнять потенциально полное сканирование массива с помощью in_array(), а затем еще одно потенциально полное сканирование снова с помощью array_search(). Это просто плохая практика. Моя позиция остается неизменной - этот ответ допускает ошибки, которых не было в предыдущих ответах. Исправление этого ответа только сделает его дублирующим из более ранних ответов. Эта страница будет улучшена, если этот ответ будет удален.
 – 
mickmackusa
24 Авг 2021 в 13:27

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

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
6
4 revs, 4 users 30% 19 Фев 2019 в 13:55
5
Php5: простой запуск array_pop($arr) удаляет последнюю запись. `=` Не требуется.
 – 
Krista K
16 Сен 2014 в 04:33

Я пришел сюда, потому что хотел увидеть, есть ли более элегантное решение этой проблемы, чем использование 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'];
1
Jed Lynch 19 Окт 2020 в 18:29
<?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 )
7
Peter Mortensen 22 Фев 2019 в 12:53
Нет смысла проверять, существует ли ключ перед вызовом unset(). Если ключ не найден в массиве, то unset() ничего не сделает (как и ожидалось). unset() и array_slice() уже были рекомендованы до публикации этого ответа. Этот ответ не добавляет новой ценности этой странице.
 – 
mickmackusa
22 Авг 2021 в 05:57

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();
?>
21
Peter Mortensen 19 Фев 2019 в 13:57

Решения:

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

13
Peter Mortensen 22 Фев 2019 в 13:06

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

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

29
Ahmad Mobaraki 22 Авг 2021 в 07:20
unset() уже несколько раз рекомендовали на этой странице несколькими годами ранее. array_search() с unset() был продемонстрирован еще в 2011 году. stackoverflow.com/a/8135667/2943403 Этот ответ не добавляет новой ценности этой странице.
 – 
mickmackusa
22 Авг 2021 в 05:46
Возможно, вы правы, всю информацию в этом ответе можно найти в других ответах. но, возможно, наличие всего этого в одном ответе для разных условий и простое объяснение кому-то сэкономит время. так что это можно рассматривать как ценность, я думаю!
 – 
Ahmad Mobaraki
22 Авг 2021 в 06:34
Это один из способов увидеть это. Другой способ увидеть эту страницу с несколькими вкладками - это «сильно раздутые советы». Исследователям приходится прокручивать один и тот же совет снова и снова, чтобы убедиться, что они принимают во внимание все относящиеся к делу советы. Поскольку ответы представляют собой смесь одной и нескольких техник, И многие ответы говорят об одном и том же - опыт исследователя сильно пострадал. Представьте, если вам нужен совет с этой страницы. Хотели бы вы прочитать роман, полный лишних советов? Я бы не стал.
 – 
mickmackusa
22 Авг 2021 в 06:37
Если вы лично обнаружили, что предыдущие ответы были «неясными» или нуждались в более подробной информации, вы можете отредактировать эти ответы, чтобы лучше помочь исследователям, вместо того, чтобы публиковать новый ответ. Это означает, что лучший совет распределяется по меньшему количеству общих ответов.
 – 
mickmackusa
22 Авг 2021 в 06:38
Я согласен с вами во многих случаях. Но я думаю, что целью редактирования ответа является исправление некоторых слов или мелких технических опечаток, а не расширение / изменение его. Как бы то ни было, я сам потратил некоторое время, чтобы изучить все ответы и придумать простой и эффективный способ сделать это, и придумал это решение, и я подумал, что, возможно, будет хорошей идеей поделиться им. Я думаю, что причина, по которой он получает некоторые положительные голоса, заключается в том, что у других людей такая же ситуация, и они находят этот ответ простым, понятным и охватывающим! @mickmackusa
 – 
Ahmad Mobaraki
22 Авг 2021 в 06:50