Usuwanie elementu z tablicy w PHP

Należy zauważyć, że unset() będzie zachowywał indeksy nietknięte, czego można się spodziewać, używając indeksów łańcuchowych( tablica jako 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)
} */

Więc array_splice() może być używany, 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 wyjście 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() będzie ładnie reindexować tablicę liczbową, ale usunie wszystkie łańcuchy klawiszy z tablicy i zastąpi je liczbami. Jeśli chcesz zachować nazwy kluczy (ciągi znaków) lub reindex tablicy, 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 numerycznie indeksowaną tablicę, gdzie wszystkie wartości są unikalne (lub nie są unikalne, ale chcesz usunąć wszystkie instancje określonej wartości), możesz po prostu użyć array_diff (), aby usunąć pasujący element, jak to:

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

To wyświetla:

4
3

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

Również dla elementu nazwanego:

unset($array["elementName"]);

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

    echo $fruit;
?>

Wyjście:

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

fruit1

Niszczenie pojedynczego elementu tablicy

unset()

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

Wyjście będzie:

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

Jeśli chcesz ponownie indeksować tablicę:

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

Wtedy wynik będzie:

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

WyĹ 'Ä ... czenie elementu z koĹ" ca tablicy - zwraca 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 , - return 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);

Wyjście będzie:

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

Aby uniknąć szukania można bawić się array_diff:

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

W tym przypadku nie trzeba szukać/używać klucza.

Jeśli musisz usunąć wiele wartości w tablicy, a wpisy w niej są obiektami lub danymi strukturalnymi, [array_filter][1] jest najlepszym rozwiązaniem. Te wpisy, które zwracają true z funkcji callback 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

Dla tablic asocjacyjnych, użyj unset:

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

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

Tablice liczbowe

Dla tablic numerycznych, użyj array_splice:

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

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

Uwaga

Za pomocą unset dla tablic numerycznych nie spowoduje błędu, ale spowoduje bałagan w indeksach:

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

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

unset() niszczy określone zmienne.

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

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

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

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

Odpowiedzią powyższego kodu będzie bar.

Do unset() zmiennej globalnej wewnątrz funkcja:

<?php
    function foo()
    {
        unset($GLOBALS['bar']);
    }

    $bar = "something";
    foo();
?>

Jeśli indeks jest określony:

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

Jeżeli 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']
}

Warunek if jest konieczny ponieważ jeśli index nie zostanie znaleziony, unset() automatycznie usunie pierwszy element tablicy, który nie jest tym, czego chcemy.

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

Wyjście:

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

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

Rozwiązania:

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

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

1. aby usunąć wiele elementów niezgodnych, użyj również unset():

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

1. aby usunąć wiele sąsiednich elementów, użyj array_splice():

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

Dalsze wyjaśnienie:

Używanie 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 łańcuch do elementu:

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

Oprócz składni, istnieje logiczna różnica między używaniem unset () a przypisywaniem " do elementu. Pierwszy mówi This doesn't exist anymore, podczas gdy drugi mówi This 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, gdyby firma zaprzestała produkcji koła zębatego modelu XL1000, zaktualizowałaby swoje zapasy z:

unset($products['XL1000']);

$products['XL1000'] = 0;

Jeśli unset() element, PHP dostosowuje tablicę tak, aby pętla nadal działała poprawnie. Nie zagęszcza tablicy, aby wypełnić brakujące otwory. To mamy na myśli, gdy mówimy, że wszystkie tablice są asocjacyjne, nawet jeśli wydają się być liczbowe. 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

To zwiększ tablicę do gęsto wypełnionej tablicy liczbowej, użyj array_values():

$animals = array_values($animals);

Alternatywnie, array_splice () automatycznie reindeksuje tablice, aby uniknąć pozostawiania 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 zezwalając na losowy dostęp. Aby bezpiecznie usunąć pierwszy lub ostatni element z tablicy, użyj odpowiednio array_shift() i array_pop().

Chciałbym tylko powiedzieć, że miałem konkretny obiekt, który miał zmienne atrybuty (w zasadzie odwzorowywał tabelę i zmieniałem kolumny w tabeli, więc atrybuty w obiekcie, odzwierciedlające tabelę, również się zmieniały):

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 $fields był po prostu, więc nie muszę szukać wszędzie w kodzie, gdy są zmieniane, po prostu patrzę na początek klasy i zmieniam listę atrybutów i zawartość tablicy $fields, aby odzwierciedlić nowy atrybuty.

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

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

Wykonaj domyślne funkcje:

• PHP: unset

unset() niszczy określone zmienne. Więcej informacji można znaleźć w PHP unset

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

unset($Array[2]);

• PHP: array_pop

Funkcja array_pop() usuwa ostatni element tablicy. Więcej informacji można znaleźć w PHP array_pop

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

array_pop($Array);

• PHP: array_splice

Funkcja array_splice() usuwa wybrane elementy z tablica i zastępuje ją nowymi elementami. Więcej informacji można znaleźć w PHP array_splice

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

array_splice($Array,1,2);

• PHP: array_shift

Funkcja array_shift() usuwa pierwszy element z tablicy. Więcej informacji można znaleźć w PHP array_shift

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

array_shift($Array);

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

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

Aby usunąć storage, wykonaj:

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

I otrzymujesz:

Array
(
    [user_id] => 193
)

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

Utwórz swoją tablicę w zmiennej $array i tam, gdzie umieściłem 'element, który chcesz usunąć', umieścisz coś w stylu: "a". A jeśli chcesz usunąć wiele elementów, to: "a", "b".

Dwa sposoby usuwania pierwszej pozycji tablicy z zachowaniem kolejności indeksu oraz jeśli nie znasz nazwy klucza pierwszej pozycji.

Rozwiązanie # 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 # 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ć taki wynik:

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

Unset () wiele, fragmentowanych elementów z tablicy

O ile unset() zostało tu już wspomniane kilka razy, to nie zostało jeszcze wspomniane, że unset() akceptuje wiele zmiennych, co ułatwia usuwanie wielu, nie będących w ciągłej sprzeczności elementów z tablicy w ramach 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 nie powiedzie się (byłoby nieco łatwiej używać unset () dynamicznie chociaż).

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

$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 przez skopiowanie tablicy

$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 oparty na kluczu:

Użyj funkcji unset 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 funkcji array_search, 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
        )

*/

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

Wyjście

 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 )

Dla tablic asocjacyjnych, z nie-całkowitymi kluczami:

Po Prostu, unset($array[$key]) by zadziałało.

Dla tablic posiadających klucze całkowite 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);

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

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

print_r($arrayName);

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 )