it-swarm.com.ru

PHP: удалить элемент из массива

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

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

2149
Ben

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

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

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

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

\unset() method

Обратите внимание, что при использовании \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() method

Если вы используете \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() method

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

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

2462
Konrad Rudolph

Следует отметить, что 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() after 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)
} */
1325
Stefan Gehrig
  // 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
)
344
Marcel Cozma
$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}
182
liamvictor
unset($array[$index]);
70
Eran Galperin

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

60
Robin Nixon

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

unset($array["elementName"]);
56
DefenestrationDay

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

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
29
KTAnj
<?php
    $stack = array("fruit1", "fruit2", "fruit3", "fruit4");
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Результат: 

Array
(
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
)

fruit1
26
Saurabh Chandra Patel

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

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

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

24
Mugoma J. Okomba

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();
?>
17
Ankit Aggarwal

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

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

Для ассоциативных массивов используйте 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)
16
John Slegers
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}
15
GigolNet Guigolachvili

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

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

я)

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

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

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

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

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

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

Array
(
    [user_id] => 193
)
7
Tebe

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

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

7
Oxydel

Решения:

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

5
Star

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
Kristoffer Bohmann

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

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

*/
4
MahdiY

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

$arr = array('orange', 'banana', 'Apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
4
Sunil Kumar Sain
<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

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

4
Joshua Charles Pickwell
<?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 )
4
UMAR FAROOQUE KHAN

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

Просто unset($array[$key]) будет работать.

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

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

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

2
Rahul Patel

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

Решение № 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"
}
2
Nabi K.A.Z.

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

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

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

1
Wakar Ahmad Khan

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

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

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 )
1
inrsaurabh

Если вы знаете индекс:

$arr = ['a', 'b', 'c'];
$index = 0;

unset($arr[$index]);  // result: $arr = ['b', 'c']

Если вы не знаете индекс, вы должны сначала искать значение:

$arr = ['a', 'b', 'c'];
$index = array_search('a',$arr);

unset($arr[$index]);  // result: $arr = ['b', 'c']
0
Ahmad Mobaraki

Мы можем изменить содержимое переменной со ссылкой, используя foreach:

<?php
    // Remove all elements in the array
    foreach ($array as &$arr) {
        $arr = null;
    }
0
Pascal Tovohery
$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

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

print_r($arrayName);
0
Javed Khan

Есть два метода для решения этой задачи: unset () и array_splice ()

Допустим, два массива:

$array_1 = array('a'=>'One', 'b'=>'Two', 'c'=>'Three');

$array_2 = array('Red', 'Yellow', 'White', 'Black', 'Green');

С неустановленным ()

syntax - unset(array_element)

unset($array_1['a']); // Any valid key
unset($array_2[0]); // Any valid index
  • после удаления элемента массива индекс массива не меняется

С помощью array_splice ()

syntax - array_splice(array, index, length)

array_splice($array_1, 1, 1); // Remove one element from $array_1 from index 1
array_splice($array_2, 3, 1); // Remove one element from $array_2 from index 3
  • Все элементы массива переиндексируются после удаления элемента из массива
0
Mohammad Wasim

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

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

0
Drake Boein