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

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

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

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

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

unset()

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

Код:

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

Код:

$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(), он не изменит ключи массива.

Код:

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

Выход:

[
    [1] => b
]

\array_diff_key() метод

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

Код:

$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[$index]);

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

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

unset($array["elementName"]);

  // 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]);
}

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

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

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

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

    echo $fruit;
?>

Выход:

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

fruit1

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

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

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
)

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

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: не установлено

unset() уничтожает указанные переменные. Для получения дополнительной информации вы можете обратиться к PHP не установлен

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

*/

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

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

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

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

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

Решения:

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;

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

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 )

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

Вы можете использовать метод 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 массива

Есть два метода для выполнения этой задачи: 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

• Все элементы массива переиндексируются после удаления элемента из массива

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

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

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

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

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

2. array_splice($array, 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"
}

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

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

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

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

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

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

print_r($arrayName);

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

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

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

Используйте unset для удаления ключа Street:

<?php
    $arr1 = array("Name" => "Johm", "Street" => "Waall", "Country" => "India");                
    unset($arr1["Street"]);               
?>

РЕЗУЛЬТАТ:

array("Name" => "Johm","Country" => "India")`

Это не приведет к повторной индексации массива после удаления значения, поэтому используйте array_splice();.

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