Usuwanie elementu z tablicy w PHP


2513

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.


14
Nie chciałbym, aby odpowiedź Konrada była najprostsza na zadany problem. Przy unset()iteracjach nad tablicą nie będzie już uwzględniona usunięta wartość. OTOH, to prawda, że ​​odpowiedź Stevana jest obszerna i właściwie to była odpowiedź, której szukałem - ale nie OP :)
brandizzi

32
@danip Łatwość znalezienia się w instrukcji nie wyklucza pytania na temat StackOverflow. Jeśli pytanie było duplikatem pytania StackOverflow, może nie być tutaj. StackOverflow to dobre miejsce, aby znaleźć odpowiedzi jako opcję, nawet zanim zajrzysz do instrukcji.
Dan Nissenbaum

5
@unset ($ array [$ key]); $ tablica = wartości_szablonowe ($ tablica);
trojan

Powiązane pytanie dotyczące usuwania tego w pętli foreach: stackoverflow.com/questions/1949259/...
Legolas

Jeśli chcesz usunąć klucze z tablicy tablicy (tablica asocjacyjna), zobacz rozwiązanie na stackoverflow.com/a/47978980/1045444
Somnath Muluk

Odpowiedzi:


2871

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.


25
@AlexandruRada Nie, powiedziałeś „nie używaj tego” - a to tylko nonsens. Możesz bezpiecznie korzystać z tej metody, gdy traktujesz tablicę jako taką, jaką jest - słownik. Tylko jeśli oczekujesz kolejnych indeksów numerycznych, musisz użyć czegoś innego.
Konrad Rudolph

2
@Alexander Użyj array_splice, jak opisano w innych odpowiedziach.
Konrad Rudolph

1
@AlexandruRada Nie ma sposobu, można mieć array (3) { [0]=>int(0) ..., gdy unset($x[2])od $x = array(1, 2, 3, 4);Wynik musi być var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }(to chyba literówka)
inemanja

5
unsetMożna mieć wiele argumentów: void unset ( mixed $var [, mixed $... ] ).
Константин Ван

3
array_filter jest również opłacalną metodą. Szczególnie dobrze, jeśli nie chcesz mutować tablicy, ale również nie indeksuje ona ponownie, co może być problemem z json_encode. php.net/manual/en/function.json-encode.php#94157
dotnetCarpenter

1358

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

42
Warto zauważyć, że gdy używasz array_splice (), musisz znać PRZESUNIĘCIE, nie klucz, ale przesunięcie (!) Dowolnego elementu, który chcesz usunąć
Tom

18
@Tom: Dla zwykłej tablicy (która jest ciągle indeksowana liczbą całkowitą) przesunięcie jest indeksem. To array_splicemoże mieć sens (między innymi).
Stefan Gehrig

5
Tak, oczywiście, ale pamiętaj tylko o tym, jeśli sfałszujesz tablicę przed użyciem splice
Tom

4
Z podstawowego testu usuwania tony elementów z gigantycznej tablicy, array_splice wydaje się być o wiele szybszy i wymaga mniej pamięci. Jest to zgodne z tym, czego oczekiwałbym: array_values ​​() wydaje się tworzyć kopię tablicy, podczas gdy array_splice działa na swoim miejscu.
Doug Kavendek,

4
array_values ​​to przydatne podejście, gdy usuwasz elementy w pętli i chcesz, aby indeksy były spójne, ale potem chcesz je skompresować po pętli.
Rorrik

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

$ get_merged_values ​​= array_merge ($ data ['res'], $ data ['check_res']); kiedy wydrukuję to print_r ($ get_merged_values); wyświetla następujące. Array ([0] => Array ([kod_menu] => 2 [nazwa_menu] => Plant [nr_menu]]>> 1) [1] => Array ([kod_menu] => 3 [nazwa_menu] => Linia [nr_menu] => 2)) Ale muszę uzyskać wartości menu_kod i nazwa_menu za pomocą odpowiednio $ get_merged_values ​​['menu_code'] i $ get_merged_values ​​['nazwa_menu]] zamiast używania $ get_merged_values ​​[0] [kod_menu], $ get_merged_values ​​[0 ] [nazwa_menu]. proszę pomóż mi jak to zrobić?
haker serca

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

4
Dobrze byłoby wyjaśnić, że ta odpowiedź służy do usunięcia elementu, gdy znasz wartość, ale nie klucz. Zauważ, że usuwa tylko PIERWSZE wystąpienie wartości; aby znaleźć wszystkie klucze dla wartości, użyj array_keys
ToolmakerSteve


65

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.


64

Ponadto dla nazwanego elementu:

unset($array["elementName"]);

$a = array("A"=>1, "B"=>2, "C"=>"a"); print_r($a); unset($a["B"]); print_r($a); daje (sformatowany): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
DefenestrationDay

Wygląda na to, że nie można rozbroić elementów tablicy indeksowanych przez ciąg znaków (generuje „Błąd krytyczny: Nie można cofnąć przesunięcia łańcucha”). Nie sądzę, że tak było zawsze, ale na pewno od PHP 5.3.10 i prawdopodobnie wcześniej
carpii

6
@carpii PHP może usuwać elementy z tablicy asocjacyjnej. Błąd krytyczny powstaje, gdy próbujesz użyć polecenia unset ($ var ['key']) na łańcuchu zamiast tablicy Na przykład: $ array = array ('test' => 'value', 'another' => ' wartość ”); unset ($ array ['test']); // Usuwa element „test” z tablicy zgodnie z oczekiwaniami $ array = 'test'; unset ($ array ['test']); // Zgłasza „Błąd krytyczny: Nie można cofnąć przesunięć ciągów” zgodnie z oczekiwaniami
Jimbo,

Tutaj musisz znać kluczową nazwę, lepiej: stackoverflow.com/a/52826684/1407491
Nabi KAZ

33

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

1
array_shiftIndeks re kluczowe elementy, czy jest to liczba całkowita, więc jest zły, więc można użyć tego: stackoverflow.com/a/52826684/1407491
Nabi KAZ

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

    echo $fruit;
?>

Wynik:

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

fruit1

14
Pamiętaj, że array_shiftmożna usunąć tylko pierwszy element w tablicy. podobnie użyj, array_popaby usunąć ostatni element w tablicy.
Jasir

1
Odpowiedź dotyczy tylko pierwszego elementu tablicy i nie odpowiada na pytanie ogólne.
sweisgerber.dev

@sebweisgerber masz rację, ale nie sądzę, że jest to zły ans i muszę zlekceważyć ten ans. Pytanie brzmi: usuń element, nie wspominając o żadnej pozycji.
Saurabh Chandra Patel

27

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.


21

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

20

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)

19

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 ) 

Dlaczego jest to tak niedoceniane?
Fr0zenFyr,

19

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

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

12

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


1
jeśli wartość nie zostanie znaleziona, usunie pierwszy element. dodaj test dla unset: if ($ index! == false) unset ($ arr [$ index]);
MyRealNameIsBlaze

@MyRealNameIsBlaze dziękuję, naprawiono
Ahmad Mobaraki

9

Rozwiązania:

  1. Aby usunąć jeden element, użyj unset () :
unset($array[3]);
unset($array['foo']);
  1. Aby usunąć wiele niesąsiadujących elementów, użyj również unset () :
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. 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 () .


8

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
)

Do czego array_filtersłuży?
David

usunąć elementy falsy
Tebe

8

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


8

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

7
<?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”.


7

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

6

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

6

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
        )

*/

6

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

5

Użyj następującego kodu:

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

4
php5: po prostu uruchomienie array_pop($arr)usuwa ostatni wpis. Nie jest wymagane `=`.
Chris K

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

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 )

4

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


2

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 )

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

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

print_r($arrayName);
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.