Czy istnieje prosty sposób na usunięcie elementu z tablicy za pomocą PHP, aby foreach ($array)nie zawierał już tego elementu?

Myślałem, że ustawienie tego by nullto zrobiło, ale najwyraźniej to nie działa.

Istnieją różne sposoby usuwania elementu tablicy, przy czym niektóre z nich są bardziej przydatne do niektórych określonych zadań niż inne.

Usuń jeden element tablicy

Jeśli chcesz usunąć tylko jeden element tablicy, którego możesz użyć unset()lub alternatywnie \array_splice().

Również jeśli masz wartość i nie znasz klucza do usunięcia elementu, możesz użyć go \array_search()do uzyskania klucza.

unset()

Zauważ, że kiedy użyjesz unset()klawiszy tablicy, nie zmienisz / ponownie indeksujesz. Jeśli chcesz ponownie zindeksować klucze, których możesz użyć, \array_values()po unset()czym zamienisz wszystkie klucze na klucze numeryczne od 0.

Kod

<?php

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

?>

Wynik

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

\array_splice() metoda

Jeśli użyjesz, \array_splice()klucze zostaną automatycznie ponownie zindeksowane, ale klucze skojarzone nie zmienią się, w przeciwieństwie do \array_values()których zamieni wszystkie klucze na klucze numeryczne.

Również \array_splice()wymaga przesunięcia, nie klucz! jako drugi parametr.

Kod

<?php

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

?>

Wynik

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

array_splice()tak samo jak unset()weź tablicę przez odniesienie, a to oznacza, że ​​nie chcesz przypisywać zwracanych wartości tych funkcji z powrotem do tablicy.

Usuń wiele elementów tablicy

Jeśli chcesz usunąć wiele elementów tablicy i nie chcesz wywoływać unset()ani \array_splice()wiele razy, możesz użyć funkcji \array_diff()lub w \array_diff_key()zależności od tego, czy znasz wartości lub klucze elementów, które chcesz usunąć.

\array_diff() metoda

Jeśli znasz wartości elementów tablicy, które chcesz usunąć, możesz użyć \array_diff(). Tak jak poprzednio unset(), nie zmieni / nie zindeksuje kluczy tablicy.

Kod

<?php

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

?>

Wynik

[
    [1] => b
]

\array_diff_key() metoda

Jeśli znasz klucze elementów, które chcesz usunąć, to chcesz użyć \array_diff_key(). Tutaj musisz upewnić się, że przekazujesz klucze jako klucze w drugim parametrze, a nie jako wartości. W przeciwnym razie musisz odwrócić tablicę za pomocą \array_flip(). Także tutaj klucze się nie zmienią / reindex.

Kod

<?php

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

Wynik

[
    [1] => b
]

Również jeśli chcesz użyć unset()lub \array_splice()usunąć wiele elementów o tej samej wartości, możesz użyć, \array_keys()aby uzyskać wszystkie klucze dla określonej wartości, a następnie usunąć wszystkie elementy.

Należy zauważyć, że unset()indeksy pozostaną nietknięte, czego można się spodziewać podczas korzystania z indeksów łańcuchowych (tablica jako tablica hashtable), ale może być dość zaskakujące, gdy mamy do czynienia z tablicami indeksowanymi liczbami całkowitymi:

$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()Może być więc użyty, jeśli chcesz znormalizować swoje klucze całkowite. Inną opcją jest użycie array_values()po 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);

To jest wynik z powyższego kodu:

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
)

Teraz array_values ​​() ładnie zindeksuje tablicę numeryczną, ale usunie wszystkie ciągi kluczy z tablicy i zastąpi je liczbami. Jeśli chcesz zachować nazwy kluczy (ciągi) lub ponownie zindeksować tablicę, jeśli wszystkie klucze są numeryczne, użyj array_merge ():

$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);

Wyjścia

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

Jeśli masz tablicę indeksowaną numerycznie, w której wszystkie wartości są unikalne (lub nie są one unikalne, ale chcesz usunąć wszystkie wystąpienia określonej wartości), możesz po prostu użyć array_diff (), aby usunąć pasujący element, na przykład:

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

Na przykład:

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

Wyświetla to:

4
3

W tym przykładzie element o wartości „Charles” jest usuwany, co można zweryfikować za pomocą wywołań sizeof (), które zgłaszają rozmiar 4 dla początkowej tablicy i 3 po usunięciu.

Ponadto dla nazwanego elementu:

unset($array["elementName"]);

Zniszcz pojedynczy element tablicy

unset()

$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);

Dane wyjściowe będą:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [3]=>
  string(1) "D"
  [4]=>
  string(1) "E"
}

Jeśli musisz ponownie zindeksować tablicę:

$array1 = array_values($array1);
var_dump($array1);

Następnie dane wyjściowe będą:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [2]=>
  string(1) "D"
  [3]=>
  string(1) "E"
}

Usuń element z końca tablicy - zwróć wartość usuniętego elementu

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

Wyjście będzie

Array
(
    [0] => orange
    [1] => banana
    [2] => apple
)
Last Fruit: raspberry

Usuń pierwszy element (czerwony) z tablicy , - zwróć wartość usuniętego elementu

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

Dane wyjściowe będą:

Array
(
    [b] => green
    [c] => blue
)
First Color: red

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

    echo $fruit;
?>

Wynik:

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

fruit1

Aby uniknąć wyszukiwania, możesz bawić się z array_diff:

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

W takim przypadku nie trzeba wyszukiwać / używać klucza.

Jeśli musisz usunąć wiele wartości z tablicy, a wpisy w tej tablicy są obiektami lub danymi strukturalnymi, [array_filter][1]to najlepszy wybór. Wpisy, które zwracają wartość true z funkcji wywołania zwrotnego, zostaną zachowane.

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

Tablice asocjacyjne

W przypadku tablic asocjacyjnych użyj unset:

$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);

// RESULT: array('a' => 1, 'c' => 3)

Tablice numeryczne

W przypadku tablic numerycznych użyj array_splice:

$arr = array(1, 2, 3);
array_splice($arr, 1, 1);

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

Uwaga

Użycie unsettablic numerycznych nie spowoduje błędu, ale zepsuje indeksy:

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

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

Jeśli chcesz usunąć wiele elementów z tablicy asocjacyjnej, możesz użyć array_diff_key () (tutaj używane z 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);

Wynik:

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

unset() niszczy określone zmienne.

Zachowanie się unset()wewnątrz funkcji może się różnić w zależności od typu zmiennej, którą próbujesz zniszczyć.

Jeśli zglobalizowana zmienna znajduje się unset()wewnątrz funkcji, tylko zmienna lokalna jest niszczona. Zmienna w środowisku wywołującym zachowa tę samą wartość, jak poprzednio unset().

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

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

Odpowiedzią na powyższy kod będzie bar .

Do unset()zmiennej globalnej wewnątrz funkcji:

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

Jeśli indeks jest określony:

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

Jeśli indeks NIE jest określony:

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

ifWarunek jest konieczny, ponieważ jeśli indexnie zostanie znaleziony, unset()automatycznie usuwa pierwszy element tablicy, który jest nie to, co chcemy

Rozwiązania:

1. Aby usunąć jeden element, użyj unset () :

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

2. Aby usunąć wiele niesąsiadujących elementów, użyj również unset () :

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

3. Aby usunąć wiele ciągłych elementów, użyj array_splice () :

array_splice($array, $offset, $length);

Dalsze wyjaśnienia:

Korzystanie z tych funkcji usuwa wszystkie odniesienia do tych elementów z PHP. Jeśli chcesz zachować klucz w tablicy, ale z pustą wartością, przypisz pusty ciąg do elementu:

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

Oprócz składni istnieje logiczna różnica między użyciem unset () a przypisywaniem elementu do elementu. Pierwszy mówi, This doesn't exist anymore,a drugi mówiThis still exists, but its value is the empty string.

Jeśli masz do czynienia z liczbami, przypisanie 0 może być lepszą alternatywą. Tak więc, jeśli firma zaprzestanie produkcji koła łańcuchowego modelu XL1000, zaktualizuje swoje zapasy o:

unset($products['XL1000']);

Jeśli jednak tymczasowo zabrakło zębatek XL1000, ale planowano w tym tygodniu otrzymać nową przesyłkę z fabryki, lepiej:

$products['XL1000'] = 0;

Jeśli usuniesz () element, PHP dostosuje tablicę, aby pętla nadal działała poprawnie. Nie zagęszcza tablicy w celu wypełnienia brakujących otworów. To mamy na myśli, gdy mówimy, że wszystkie tablice są asocjacyjne, nawet jeśli wydają się być liczbami. Oto przykład:

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

Aby skompresować tablicę do gęsto wypełnionej tablicy numerycznej, użyj array_values ​​() :

$animals = array_values($animals);

Alternatywnie, array_splice () automatycznie ponownie indeksuje tablice, aby uniknąć pozostawienia dziur:

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

Jest to przydatne, jeśli używasz tablicy jako kolejki i chcesz usunąć elementy z kolejki, jednocześnie umożliwiając losowy dostęp. Aby bezpiecznie usunąć pierwszy lub ostatni element z tablicy, użyj odpowiednio array_shift () i array_pop () .

Załóżmy, że masz następującą tablicę:

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

Aby usunąć storage:

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

I dostajesz:

Array
(
    [user_id] => 193
)

Chciałbym tylko powiedzieć, że miałem konkretny obiekt, który miał zmienne atrybuty (było to po prostu mapowanie tabeli i zmieniłem kolumny w tabeli, więc atrybuty w obiekcie odzwierciedlające tabelę również się różnią):

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

Cały cel $fieldsbył po prostu, więc nie muszę patrzeć wszędzie w kodzie, gdy są one zmieniane, patrzę tylko na początek klasy i zmieniam listę atrybutów oraz zawartość tablicy $ fields, aby odzwierciedlić nowy atrybuty

Postępuj zgodnie z domyślnymi funkcjami:

ja)

$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"]);
?>

Utwórz tablicę w zmiennej, $arraya następnie w miejscu, w którym umieściłem element, który chcesz usunąć, umieść coś w stylu: „a”. A jeśli chcesz usunąć wiele elementów, to: „a”, „b”.

Użyj array_search, aby uzyskać klucz i usunąć go z unset, jeśli zostanie znaleziony:

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

unset () wiele pofragmentowanych elementów z tablicy

Chociaż unset()wspomniano tu kilkakrotnie, należy jeszcze wspomnieć, że unset()akceptuje wiele zmiennych, co ułatwia usuwanie wielu, niesąsiadujących elementów z tablicy w jednej operacji:

// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]

unset () dynamicznie

unset () nie akceptuje tablicy kluczy do usunięcia, więc poniższy kod się nie powiedzie (ułatwiłoby to dynamiczne użycie unset ()).

$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);

Zamiast tego można użyć dynamicznie unset () w pętli foreach:

$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
    unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]

Usuń klucze tablicy, kopiując tablicę

Jest jeszcze jedna praktyka, o której jeszcze nie wspomniano. Czasami najprostszym sposobem na pozbycie się niektórych kluczy tablicy jest po prostu skopiowanie $ array1 do $ 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 ];

Oczywiście ta sama praktyka dotyczy ciągów tekstowych:

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

Usuń element tablicy na podstawie klucza:

Użyj unsetfunkcji jak poniżej:

$a = array(
       'salam',
       '10',
       1
);

unset($a[1]);

print_r($a);

/*

    Output:

        Array
        (
            [0] => salam
            [2] => 1
        )

*/

Usuń element tablicy na podstawie wartości:

Użyj array_searchfunkcji, aby uzyskać klucz elementu i użyj powyższego sposobu, aby usunąć element tablicy, jak poniżej:

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

*/

Dwa sposoby na usunięcie pierwszego elementu tablicy z zachowaniem kolejności indeksu, a także, jeśli nie znasz nazwy klucza pierwszego elementu.

Rozwiązanie nr 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);

Rozwiązanie nr 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]);

Dla tych przykładowych danych:

$array = array(10 => "a", 20 => "b", 30 => "c");

Musisz mieć ten wynik:

array(2) {
  [20]=>
  string(1) "b"
  [30]=>
  string(1) "c"
}

Użyj następującego kodu:

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

Wynik

 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 )

W przypadku tablic asocjacyjnych z kluczami niecałkowitymi:

Po prostu, unset($array[$key]) by działało.

W przypadku tablic z kluczami całkowitymi i jeśli chcesz zachować swoje klucze:

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

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

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

To może pomóc ...

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

Wynik będzie:

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