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

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

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

15.12.2008 20:28:55
Я бы не сказал, что ответ Конрада является самым простым для поставленной задачи. С unset()итерациями по массиву больше не будет удалено значение. OTOH, это правда, что ответ Стевана достаточно и, на самом деле, был ответ, который я искал - но не OP :)
brandizzi 26.07.2012 17:05:45
@danip Легкость поиска в руководстве не исключает вопроса о StackOverflow. Если бы вопрос был дублирующим вопросом StackOverflow, он мог бы не принадлежать здесь. StackOverflow - это хорошее место, где можно найти ответы в качестве альтернативы, прежде чем искать в руководстве.
Dan Nissenbaum 11.02.2014 05:18:34
@unset ($ массив [$ ключ]); $ array = array_values ​​($ array);
trojan 4.09.2014 12:55:29
Связанный вопрос об удалении этого в цикле foreach: stackoverflow.com/questions/1949259/…
Legolas 23.09.2015 08:18:17
Если вы хотите удалить ключи из массива массива (ассоциативный массив), см. Решение на stackoverflow.com/a/47978980/1045444
Somnath Muluk 26.12.2017 13:10:10
30 ОТВЕТОВ
РЕШЕНИЕ

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

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

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

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

unset()

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

Код

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    unset($array[1]);
                //↑ Key which you want to delete

?>

Вывод

[
    [0] => a
    [2] => c
]

\array_splice() метод

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

Также \array_splice()необходимо смещение, а не ключ! как второй параметр.

Код

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    \array_splice($array, 1, 1);
                        //↑ Offset which you want to delete

?>

Вывод

[
    [0] => a
    [1] => c
]

array_splice()То же самое, что unset()взять массив по ссылке, и это означает, что вы не хотите присваивать возвращаемые значения этих функций обратно в массив.

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

Если вы хотите удалить несколько элементов массива и не хотите вызывать unset()или \array_splice()несколько раз, вы можете использовать функции \array_diff()или в \array_diff_key()зависимости от того, знаете ли вы значения или ключи элементов, которые вы хотите удалить.

\array_diff() метод

Если вам известны значения элементов массива, которые вы хотите удалить, то вы можете использовать \array_diff(). Как и раньше, unset()он не будет изменять / переиндексировать ключи массива.

Код

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff($array, ["a", "c"]);
                               //└────────┘→ Array values which you want to delete

?>

Вывод

[
    [1] => b
]

\array_diff_key() метод

Если вы знаете ключи элементов, которые вы хотите удалить, то вы хотите использовать \array_diff_key(). Здесь вы должны убедиться, что вы передаете ключи как ключи во втором параметре, а не как значения. В противном случае вы должны перевернуть массив \array_flip(). А также здесь ключи не будут меняться / переиндексировать.

Код

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
                                    //↑           ↑ Array keys which you want to delete
?>

Вывод

[
    [1] => b
]

Также, если вы хотите использовать unset()или \array_splice()удалить несколько элементов с одинаковым значением, вы можете использовать, \array_keys()чтобы получить все ключи для определенного значения, а затем удалить все элементы.

2830
26.02.2020 10:28:11
@AlexandruRada Нет, вы сказали «не используйте это» - и это просто чепуха. Вы можете смело использовать этот метод, когда рассматриваете массив как словарь. Только если вы ожидаете последовательных числовых индексов, вам нужно использовать что-то еще.
Konrad Rudolph 13.06.2012 12:26:44
@ Александр Используйте array_splice, как описано в других ответах.
Konrad Rudolph 30.11.2013 11:21:12
@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) }(это была, вероятно, опечатка)
inemanja 19.04.2016 05:33:11
unsetможет иметь несколько аргументов: void unset ( mixed $var [, mixed $... ] ).
Константин Ван 14.04.2017 03:12:44
array_filter также является жизнеспособным методом. Особенно хорошо, если вы не хотите изменять массив, но он также не переиндексирует, что может быть проблемой с json_encode. php.net/manual/en/function.json-encode.php#94157
dotnetCarpenter 6.05.2017 00:20:39
unset($array[$index]);
83
15.12.2008 20:31:31

Следует отметить, что 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)
} */
1356
13.01.2012 17:32:09
Стоит отметить, что когда вы используете array_splice (), вам нужно знать OFFSET, а не ключ, а смещение (!) Любого элемента, который вы хотите удалить
Tom 8.06.2012 21:57:55
@Tom: для обычного массива (который непрерывно индексируется целым числом) смещение является индексом. Вот где array_spliceможет иметь смысл (среди других).
Stefan Gehrig 9.06.2012 12:18:49
Да, конечно, но просто кое-что, что нужно помнить, если вы вмешиваетесь в массив перед использованием соединения
Tom 9.06.2012 16:12:16
С помощью простого теста удаления тонны элементов из гигантского массива, array_splice выглядит намного быстрее и требует меньше памяти. Это соответствует тому, что я ожидал: array_values ​​(), кажется, делает копию массива, в то время как array_splice работает на месте.
Doug Kavendek 1.12.2014 17:01:05
array_values ​​- это полезный подход, когда вы удаляете элементы в цикле и хотите, чтобы индексы были согласованными, но затем хотели сжать их после цикла.
Rorrik 2.06.2015 16:38:47

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

unset($array["elementName"]);
62
13.11.2018 11:05:21
$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.06.2011 01:50:49
Кажется, вы не можете отменить элементы массива, проиндексированные строкой (генерирует «Неустранимая ошибка: невозможно отменить смещение строки»). Я не думаю, что это всегда имело место, но, конечно,
carpii 6.04.2012 00:29:58
@carpii PHP может удалять элементы из ассоциативного массива. Неустранимая ошибка возникает, когда вы пытаетесь использовать unset ($ var ['key']) для строки вместо массива. Например: $ array = array ('test' => 'value', 'another' => ' ценность', ); снята с охраны ($ массив [ 'тест']); // Удаляет элемент «test» из массива, как и ожидалось $ array = 'test'; снята с охраны ($ массив [ 'тест']); // Выдает «Фатальная ошибка: невозможно отменить смещение строки», как ожидалось
Jimbo 20.03.2013 09:56:35
Здесь вы должны знать имя ключа, оно лучше: stackoverflow.com/a/52826684/1407491
Nabi K.A.Z. 16.10.2018 01:23:59
  // 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
)
368
19.02.2019 10:52:43
$ get_merged_values ​​= array_merge ($ data ['res'], $ data ['check_res']); когда я распечатаю этот print_r ($ get_merged_values); это отображает следующее. Array ([0] => Array ([menu_code] => 2 [menu_name] => Plant [menu_order_no] => 1) [1] => Array ([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 ] [menu_name]. помогите пожалуйста как это сделать?
heart hacker 20.09.2018 05:56:06
$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}
202
19.02.2019 10:54:08
Было бы хорошо уточнить, что этот ответ предназначен для удаления элемента, когда вы знаете значение, а не ключ. Обратите внимание, что он удаляет только первый экземпляр значения; найти все ключи для значения, используйте array_keys
ToolmakerSteve 24.09.2016 18:09:08

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

65
26.11.2012 08:25:05

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

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
4
19.02.2019 10:55:15
PHP5: просто работает array_pop($arr)удаляет последнюю запись. Нет `=` необходимо.
Chris K 16.09.2014 00:33:10
<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Вывод:

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

fruit1
32
3.09.2019 02:54:10
Обратите внимание, что array_shiftможно удалить только первый элемент в массиве. аналогично используйте array_popдля удаления последнего элемента в массиве.
Jasir 22.07.2014 17:22:09
Ответ применим только к первому элементу массива и не отвечает на общий вопрос.
sweisgerber.dev 14.10.2014 11:03:24
@sebweisgerber Вы правы, но я не думаю, что это неправильно, и нужно понизить этот ответ. Вопрос в том, чтобы удалить элемент без упоминания какой-либо позиции.
Saurabh Chandra Patel 14.10.2014 12:13:06

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

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

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

<?php
    function destroy_foo()
    {
        global $foo;
        unset($foo);
    }

    $foo = 'bar';
    destroy_foo();
    echo $foo;
?>

Ответ приведенного выше кода будет бар .

Для unset()глобальной переменной внутри функции:

<?php
    function foo()
    {
        unset($GLOBALS['bar']);
    }

    $bar = "something";
    foo();
?>
18
19.02.2019 10:57:21

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

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, чтобы отразить новое атрибутов.

7
19.02.2019 10:59:09

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

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

Чтобы удалить storage, сделайте:

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

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

Array
(
    [user_id] => 193
)
7
14.02.2019 06:15:41
Для чего array_filterиспользуется?
David 17.03.2017 14:38:56
чтобы удалить falsy элементы
Tebe 26.06.2017 12:13:13

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

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
32
25.05.2016 18:16:34
array_shiftИндекс повторно ключевые элементы , если это целое число, так что это плохо, так что вы можете использовать это: stackoverflow.com/a/52826684/1407491
Nabi K.A.Z. 16.10.2018 01:31:09

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

я)

$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);
7
22.02.2019 09:50:41

Если вам нужно удалить несколько значений в массиве, а записи в этом массиве являются объектами или структурированными данными, [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']]
21
18.02.2016 01:40:49

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

Для ассоциативных массивов используйте 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)
20
22.02.2019 09:51:50
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}
17
30.07.2018 12:54:36

Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать 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 ) 
18
20.04.2016 21:05:31
Почему это так недооценивают?
Fr0zenFyr 2.12.2016 08:13:47
<?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 )
5
22.02.2019 09:53:46

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

<?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 )
1
22.02.2019 09:56:25

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

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

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

27
22.09.2016 22:10:50

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

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

        $value = $array[$key];
        unset($array[$key]);
        return $value;
    }

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

-3
22.02.2019 09:58:33
Добавил это, потому что это было то, как я попал сюда от Google
SparK 22.02.2019 16:01:34
Несмотря на то, что за него много проголосовали, я его здесь оставлю, потому что это важно для меньшинства в сообществе.
SparK 13.05.2019 14:52:12

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

Используйте 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
        )

*/
5
22.02.2019 10:01:38

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

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

-1
22.02.2019 10:02:11
<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

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

6
22.02.2019 10:02:51

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' ]
5
14.02.2019 06:14:48

Решения:

  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;

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

8
22.02.2019 10:06:37

unsetне меняет индекс, но array_spliceделает:

$arrayName = array('1' => 'somevalue',
                   '2' => 'somevalue1',
                   '3' => 'somevalue3',
                   500 => 'somevalue500',
                  );


    echo $arrayName['500'];
    //somevalue500
    array_splice($arrayName, 1, 2);

    print_r($arrayName);
    //Array ( [0] => somevalue [1] => somevalue500 )


    $arrayName = array( '1' => 'somevalue',
                        '2' => 'somevalue1',
                        '3' => 'somevalue3',
                        500 => 'somevalue500',
                      );


    echo $arrayName['500'];
    //somevalue500
    unset($arrayName[1]);

    print_r($arrayName);
    //Array ( [0] => somevalue [1] => somevalue500 )
0
22.02.2019 10:08:32
$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // Here is the key to be deleted
echo '<br>';
array_values($x);
var_dump($x);
0
15.08.2019 15:20:48
Пятая строка должна быть $x = array_values($x);.
Ian Y. 23.11.2019 10:51:29

Вы можете использовать метод array_pop, чтобы удалить последний элемент массива:

<?php
    $a = array("one", "two", "Three");
    array_pop($a);
    print_r($a);
?>
The out put will be
Array ( [0] => one[1] => two)

который удаляет только последний элемент операции LIFO массива

-3
18.06.2019 13:37:58