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

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

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

    echo $fruit;
?>

Wyjście:

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

fruit1

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.

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 function

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

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

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)

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

Chciałbym tylko powiedzieć, że miałem konkretny obiekt, który miał zmienne atrybuty (to było w zasadzie mapowanie tabeli i zmieniałem kolumny w tabeli, więc atrybuty w obiekcie, odzwierciedlając 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ł taki, żebym nie musiał szukać wszędzie w kodzie, gdy zostaną zmienione, po prostu patrzę na początek klasy i zmieniam listę atrybutów i zawartość tablicy $fields, aby odzwierciedlić nowe atrybuty.

Follow default functions

i)

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

Załóżmy, że masz taką tablicę:

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

Aby usunąć storage, wykonaj:

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

I otrzymujesz:

Array
(
    [user_id] => 193
)

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

<?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 to: "a", "b".

Unset () wiele, fragmentowanych elementów z tablicy

Podczas gdy unset () była tu wspominana kilka razy, nie zostało jeszcze wspomniane, że unset () akceptuje wiele zmiennych, co ułatwia usuwanie wielu, nieciągłych 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' ]

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życie 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 new element
$animals[ ] = 'gnu'; // add 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( ).

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

Usunięcie elementu tablicy na podstawie klucza:

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

*/

Dla tablic asocjacyjnych, z nie całkowitymi kluczami:

Po prostu, unset($array[$key]) zadziałałoby.

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

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

Podczas usuwania elementu z tablicy w PHP, dobrą funkcją do użycia jest funkcja unset. Oto przykład jego użycia:

$anArray = array("X", "Y", "Z");

unset($anArray[0]);

//'dumps' the content of $anArray to the page:
var_dump($anArray);  

Wyjście funkcji var_dump będzie następujące:

array(2) { [1]=> string(1) "Y" [2]=> string(1) "Z" }

Możesz po prostu użyć unset() do usunięcia tablicy.

Pamiętaj, że tablica musi być wyłączona po foreach funkcji.

Unset nie zmienia indeksu, ale array_splice robi

$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 key to be delete
echo '<br>';
array_values($x);
var_dump($x);