Чи є простий спосіб видалити елемент з масиву за допомогою PHP, таким чином, щоб він foreach ($array)більше не включав цей елемент?

Я думав, що встановити це nullбуде робити це, але, мабуть, це не працює.

Існують різні способи видалення елемента масиву, де деякі корисніші для певних завдань, ніж інші.

Видаліть один елемент масиву

Якщо ви хочете видалити лише один елемент масиву, який ви можете використовувати 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
)

$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}

unset($array[$index]);

Якщо у вас є масив з індексованим числом, де всі значення є унікальними (або вони не унікальні, але ви хочете видалити всі екземпляри певного значення), ви можете просто використовувати 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 після видалення.

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

unset($array["elementName"]);

Знищити один елемент масиву

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

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

У цьому випадку не потрібно шукати / використовувати ключ.

Якщо вам доведеться видалити декілька значень з масиву, а записи в цьому масиві - це об'єкти або структуровані дані, [array_filter][1]найкраще ставити. Ті записи, які повертають істину з функції зворотного дзвінка, будуть збережені.

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

Асоціативні масиви

Для асоціативних масивів використовуйте 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)

Якщо вам потрібно видалити декілька елементів із асоціативного масиву, ви можете використовувати 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()всередині функції може змінюватись залежно від типу змінної, яку ви намагаєтеся знищити.

Якщо глобалізована змінна знаходиться 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();
?>

// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

Якщо вказаний індекс:

$arr = ['a', 'b', 'c'];
$index = 0;    
unset($arr[$index]);  // $arr = ['b', 'c']

Якщо індекс НЕ вказано:

$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
   unset($arr[$index]);  // $arr = ['b', 'c']
}

Ця ifумова необхідна, тому що якщо indexїї не буде знайдено, unset()автоматично видалиться перший елемент масиву, який не є тим, що ми хочемо

Рішення:

1. Щоб видалити один елемент, використовуйте unset () :

unset($array[3]);
unset($array['foo']);

2. Для видалення декількох непостійних елементів також використовуйте unset () :

unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);

3. Щоб видалити кілька суміжних елементів, використовуйте 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 () відповідно.

Припустимо, у вас є такий масив:

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

Щоб видалити storage, виконайте:

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

І ви отримуєте:

Array
(
    [user_id] => 193
)

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

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полягала просто, тому мені не доведеться скрізь шукати код, коли вони змінені, я просто дивлюся на початок класу і змінюю список атрибутів та вміст масиву $ полів, щоб відображати новий атрибути.

Дотримуйтесь функцій за замовчуванням:

i)

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

unset($Array[2]);

ii)

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

array_pop($Array);

iii)

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

array_splice($Array,1,2);

iv)

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

array_shift($Array);

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

Створіть свій масив у змінній, $arrayа потім, куди я помістив елемент 'ви хочете видалити', ви помістите щось на кшталт: "a". І якщо ви хочете видалити кілька елементів, тоді: "a", "b".

Використовуйте array_search, щоб отримати ключ і видалити його з невстановленим, якщо його знайдено:

if (($key = array_search('word', $array)) !== false) {
    unset($array[$key]);
}

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

Видаліть елемент масиву на основі ключа:

Використовуйте 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
        )

*/

Два способи видалення першого елемента з масиву з дотриманням порядку індексу, а також, якщо ви не знаєте ключове ім'я першого елемента.

Рішення №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"
}

Використовуйте наступний код:

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

<?php
    // If you want to remove a particular array element use this method
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");

    print_r($my_array);
    if (array_key_exists("key1", $my_array)) {
        unset($my_array['key1']);
        print_r($my_array);
    }
    else {
        echo "Key does not exist";
    }
?>

<?php
    //To remove first array element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1);
    print_r($new_array);
?>


<?php
    echo "<br/>    ";
    // To remove first array element to length
    // starts from first and remove two element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1, 2);
    print_r($new_array);
?>

Вихідні дані

 Array ( [key1] => value 1 [key2] => value 2 [key3] =>
 value 3 ) Array (    [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
 Array ( [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
 Array ( [key2] => value 2 [key3] => value 3 )

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

Просто, unset($array[$key])працювало б.

Для масивів, що мають цілі ключі, і якщо ви хочете підтримувати свої ключі:

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

   unset($array[2]);
   $array = array_values($array);

2. array_splice($array, 2, 1);

Це може допомогти ...

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

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

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

print_r($arrayName);