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

Шаг первый, начните с 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-код

?>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print_r($arrayName);

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

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

Если вам нужно удалить несколько элементов из ассоциативного массива, вы можете использовать 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 ) 

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

$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

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

Для ассоциативных массивов используйте 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_filter() - ваш лучший выбор. Те записи, которые возвращают истину из функции обратного вызова, будут сохранены.

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

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

Следует отметить, что 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)
} */

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

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

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

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

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

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

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

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

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

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

Array
(
    [user_id] => 193
)

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

Решение # 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"
}

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
        )

*/

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

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

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

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

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

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

Я пришел сюда, потому что хотел увидеть, есть ли более элегантное решение этой проблемы, чем использование 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'];

<?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() уничтожает указанные переменные.

Поведение 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();
?>

Решения:

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

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

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