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

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

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

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

\unset() метод

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

Код

<?php

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

?>

Выход

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

\array_splice() метод

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

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

Код

<?php

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

?>

Выход

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

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

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

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

\array_diff() метод

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

Код

<?php

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

?>

Выход

[
    [1] => b
]

\array_diff_key() метод

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

Код

<?php

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

Выход

[
    [1] => b
]

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

Следует отметить, что unset() сохранит индексы нетронутыми, чего вы'ожидаете при использовании строковых индексов (массив как хэштейбл), но может быть довольно неожиданным при работе с массивами с целочисленными индексами:

$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)
} */

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

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

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

Например:

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

Это отображается следующая информация:

4
3

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

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

unset($array["elementName"]);

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

сбросить()

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

Поп-элемент с конца массива - возвращает значение удаленного элемента

смешанное array_pop(массив &$массив)

$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

Удалить первый элемент (красный) из массива, - возвратить значение удаляемого элемента

смешанное array_shift ( массив &$массив )

$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

<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Выход:

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

fruit1

Чтобы не делать поиск можно поиграть с array_diff`:

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

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

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

Для ассоциативных массивов, используйте сбросить:

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

Примечание

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

$arr = array(1, 2, 3);
unset($arr[1]);

// RESULT: array(0 => 1, 2 => 3)

Если нужно удалить несколько значений в массив и элементы массива являются объекты или структурированных данных, [array_filter][1] это ваш лучший ставку. Те записи, которые возвращают true из функции обратного вызова будут сохранены.

$array = [
    ['x'=>1,'y'=>2,'z'=>3], 
    ['x'=>2,'y'=>4,'z'=>6], 
    ['x'=>3,'y'=>6,'z'=>9]
];

$results = array_filter($array, function($value) {
    return $value['x'] > 2;  
}); //=> [['x'=>3,'y'=>6,z=>'9']]

Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать array_diff_key() (здесь используется с array_flip()):

$my_array = array(
  "key1" => "value 1",
  "key2" => "value 2",
  "key3" => "value 3",
  "key4" => "value 4",
  "key5" => "value 5",
);

$to_remove = array("key2", "key4");

$result = array_diff_key($my_array, array_flip($to_remove));

print_r($result);

Выход:

Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 ) 

сбросить() удаляет перечисленные переменные.

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

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

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

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

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

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

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

    $bar = "something";
    foo();
?>

Решения:

1. Чтобы удалить один элемент, используйте сбросить():

и unset($массив3); и unset($массив['фу']);

2. Чтобы удалить несколько несмежных элементов, а также использовать сбросить():

и unset($массив3, $массив5); и unset($массив['фу'], $массив['бар']);

3. Для удаления нескольких подряд идущих элементов, используйте array_splice():

array_splice($массив, $смещение, $длина);

Дальнейшее объяснение:

Используя эти функции удаляет все ссылки на эти элементы из PHP. Если вы хотите сохранить ключ в массиве, но с пустым значением, присвоить пустую строку к элементу:

$array[3] = $array['foo'] = '';

Кроме синтаксиса, там'с логическим разница между использованием и unset() и назначение '' к элементу. Первый говорит, что это не'т больше не существует, в то время как второй говорит, чтоэто по-прежнему существует, но его значение является пустой строкой`.

Если вы'ре дело с цифрами, назначая 0 может быть лучшей альтернативой. Так, если компания прекратила производство модели XL1000 звездочки, он будет обновлять его инвентаризацию с:

unset($products['XL1000']);

Однако, если он временно кончились XL1000 звездочки, но собиралась получить новый отгрузке с завода в конце этой недели, это лучше:

$products['XL1000'] = 0;

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

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

Это полезно, если вы're, используя массив в качестве очереди и хотите удалить элементы из очереди, при этом допуская произвольного доступа. Чтобы безопасно удалить первый или последний элемент из массива, используйте array_shift() и array_pop(), соответственно.

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

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

Вся цель `$Филдса было просто, так что я Дон'т придется искать везде в коде, когда они'вэ изменилось, я просто смотрю в начале класса и изменить список атрибутов и *$ поля* массив контента, чтобы отразить новые атрибуты.

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

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

Чтобы удалить "хранения", сделайте следующее:

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

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

Array
(
    [user_id] => 193
)

Выполните действия по умолчанию:

я)

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

unset($Array[2]);

второй)

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

<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

Создать массив в массив$переменная `` а потом когда я поставил 'элемент, который вы хотите удалить' вы положили что-то вроде: Я&; А". И если вы хотите удалить несколько элементов, тогда: "А", то "в”.