it-swarm.dev

PHP: Odstraňte prvek z pole

Existuje snadný způsob, jak odstranit prvek z pole pomocí PHP, takže foreach ($array) tento prvek již neobsahuje?

Myslel jsem, že nastavení na null to udělá, ale zřejmě to nefunguje.

2149
Ben

Existují různé způsoby, jak odstranit prvek pole, kde některé jsou užitečnější pro některé specifické úkoly než jiné.

Odstraňte jeden prvek pole

Pokud chcete smazat pouze jeden prvek pole, můžete použít \unset() nebo alternativně \array_splice() .

Také pokud máte hodnotu a neznáte klíč k odstranění prvku, můžete použít \array_search() pro získání klíče.

\unset() metoda

Všimněte si, že při použití \unset() klíče klíče se nezmění/reindex. Pokud chcete reindexovat klíče, můžete použít \array_values() after \unset(), který převede všechny klíče na numericky číslované klávesy od 0.

Kód

<?php

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

?>

Výstup

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

\array_splice() metoda

Pokud použijete \array_splice(), klíče se automaticky reindexují, ale asociativní klíče se nezmění na rozdíl od \array_values(), které převede všechny klíče na numerické klávesy.

Také \array_splice() potřebuje ofset, ne klíč! jako druhý parametr.

Kód

<?php

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

?>

Výstup

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

array_splice() stejný jako \unset() vezměte pole podle reference a to znamená, že nechcete přiřadit hodnoty návratu těchto funkcí zpět do pole.

Odstranit více prvků pole

Pokud chcete odstranit více prvků pole a nechcete volat \unset() nebo \array_splice() několikrát, můžete použít funkce \array_diff() nebo \array_diff_key() podle toho, zda znáte hodnoty nebo klávesy prvků, které chcete odstranit.

\array_diff() metoda

Pokud znáte hodnoty prvků pole, které chcete odstranit, můžete použít \array_diff(). Stejně jako u \unset() to nezmění/reindexuje klíče pole.

Kód

<?php

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

?>

Výstup

[
    [1] => b
]

\array_diff_key() metoda

Pokud znáte klávesy prvků, které chcete odstranit, pak chcete použít \array_diff_key(). Zde se musíte ujistit, že klíče zadáváte jako klíče v druhém parametru a nikoli jako hodnoty. V opačném případě musíte přepnout pole pomocí \array_flip() . A také zde se klíče nezmění/reindex.

Kód

<?php

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

Výstup

[
    [1] => b
]

Také pokud chcete použít \unset() nebo \array_splice() k odstranění více prvků se stejnou hodnotou, můžete použít \array_keys() pro získání všech klíčů pro určitou hodnotu a pak odstranit všechny prvky.

2462
Konrad Rudolph

Je třeba poznamenat, že unset() bude udržovat indexy nedotčené, což je to, co byste očekávali při použití řetězcových indexů (pole jako hashtable), ale může být docela překvapující, když se jedná o celočíselná indexovaná pole:

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

Takže array_splice() lze použít, pokud chcete normalizovat vaše celočíselné klíče. Další možností je použití array_values() after 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)
} */
1325
Stefan Gehrig
  // 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);

Toto je výstup z výše uvedeného kódu:

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
)

Pole array_values ​​() nyní bude pěkně reindexovat numerické pole, ale odstraní všechny klíčové řetězce z pole a nahradí je čísly. Pokud potřebujete zachovat názvy klíčů (řetězce) nebo reindexovat pole, pokud jsou všechny klávesy numerické, použijte pole array_merge ():

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

Výstupy

Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => Indigo
)
344
Marcel Cozma
$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}
182
liamvictor
unset($array[$index]);
70
Eran Galperin

Pokud máte numericky indexované pole, ve kterém jsou všechny hodnoty jedinečné (nebo nejsou jedinečné, ale chcete odstranit všechny instance určité hodnoty), můžete jednoduše použít pole array_diff () k odstranění odpovídajícího prvku, jako je tento:

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

Například:

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

Zobrazí se následující:

4
3

V tomto příkladu je prvek s hodnotou 'Charles' odstraněn, jak může být ověřeno volání sizeof (), které hlásí velikost 4 pro počáteční pole a 3 po odstranění.

60
Robin Nixon

Také pro pojmenovaný prvek:

unset($array["elementName"]);
56

Zničit jediný prvek pole

unset()

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

Výstupem bude:

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

Pokud potřebujete znovu indexovat pole:

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

Výstupem bude pak:

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

Pop elementu z konce pole - vrátí hodnotu odstraněného prvku

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

Výstupem bude

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

Odstraní první prvek (červený) z pole , - vrátí hodnotu odebraného prvku

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

Výstupem bude:

Array
(
    [b] => green
    [c] => blue
)
First Color: red
29
KTAnj
<?php
    $stack = array("fruit1", "fruit2", "fruit3", "fruit4");
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Výstup: 

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

fruit1
26

Chcete-li se vyhnout vyhledávání, můžete si hrát s array_diff:

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

V tomto případě nemusíte hledat/používat klíč.

24
Mugoma J. Okomba

unset() zničí zadané proměnné.

Chování unset() uvnitř funkce se může lišit v závislosti na typu proměnné, kterou se pokoušíte zničit.

Pokud je globalizovaná proměnná unset() uvnitř funkce, je zničena pouze lokální proměnná. Proměnná ve volajícím prostředí zachová stejnou hodnotu jako před voláním unset().

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

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

Odpověď výše uvedeného kódu bude bar .

Do unset() globální proměnné uvnitř funkce:

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

    $bar = "something";
    foo();
?>
17
Ankit Aggarwal

Pokud musíte v poli odstranit více hodnot a položky v tomto poli jsou objekty nebo strukturovaná data, je vaše nejlepší sázka [array_filter][1]. Ty položky, které vrátí true z funkce zpětného volání, budou zachovány. 

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

Asociativní pole

Pro asociativní pole použijte unset :

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

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

Číselná pole

Pro numerická pole použijte array_splice :

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

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

Poznámka

Použití unset pro numerická pole nevede k chybě, ale vaše indexy budou pokazit:

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

// RESULT: array(0 => 1, 2 => 3)
16
John Slegers
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

Pokud potřebujete odstranit více elementů z asociativního pole, můžete použít array_diff_key () (zde s 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);

Výstup:

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

Postupujte podle výchozích funkcí:

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

Předpokládejme, že máte následující pole:

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

Chcete-li soubor storage odstranit, postupujte takto:

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

A dostanete:

Array
(
    [user_id] => 193
)
7
Tebe

Chtěl bych jen říct, že jsem měl konkrétní objekt, který měl proměnné atributy (v podstatě mapoval tabulku a měnil jsem sloupce v tabulce, takže atributy v objektu odrážející tabulku by se také lišily):

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

Celý účel $fields byl spravedlivý, takže nemusím hledat všude v kódu, když se změní, jen se dívám na začátek třídy a změním seznam atributů a $ polí pole obsah, aby odrážely nové atributy.

7
Oxydel

Řešení:

  1. Chcete-li odstranit jeden prvek, použijte unset () :
unset($array[3]);
unset($array['foo']);
  1. Chcete-li odstranit více nesouvislých prvků, použijte také unset () :
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. Chcete-li odstranit více souvislých prvků, použijte array_splice () :
array_splice($array, $offset, $length);

Další vysvětlení:

Pomocí těchto funkcí se z PHP odstraní všechny odkazy na tyto prvky. Pokud chcete ponechat klíč v poli, ale s prázdnou hodnotou, přiřaďte elementu prázdný řetězec:

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

Kromě syntaxe existuje logický rozdíl mezi použitím unset () a přiřazení prvku '' prvku. První říká This doesn't exist anymore,, zatímco druhý říká This still exists, but its value is the empty string.

Pokud máte co do činění s čísly, přiřazení 0 může být lepší alternativou. Pokud tedy společnost zastaví výrobu modelu XL1000, bude aktualizovat svůj inventář pomocí:

unset($products['XL1000']);

Pokud však dočasně dojde k výpadku řetězových koleček XL1000, ale v tomto týdnu plánuje obdržet novou zásilku ze závodu, je to lepší:

$products['XL1000'] = 0;

Pokud unset () a element, PHP upraví pole tak, aby smyčka stále fungovala správně. Není kompaktní pole vyplnit chybějící otvory. To je to, co máme na mysli, když říkáme, že všechna pole jsou asociativní, i když se zdají být numerická. Zde je příklad:

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

Komprimovat pole do hustě vyplněného numerického pole, použijte array_values ​​() :

$animals = array_values($animals);

Alternativně array_splice () automaticky reindexuje pole, aby se zabránilo opuštění děr:

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

To je užitečné, pokud používáte pole jako frontu a chcete odebrat položky z fronty a zároveň povolit náhodný přístup. Chcete-li bezpečně odstranit první nebo poslední prvek z pole, použijte array_shift () a array_pop () , resp.

5
Star

unset () více fragmentovaných prvků z pole

Zatímco unset() zde bylo několikrát zmíněno, je ještě třeba zmínit, že unset() akceptuje více proměnných, což usnadňuje mazání více nesouvislých prvků z pole v jedné operaci:

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

unset () dynamicky

unset () nepřijímá pole klíčů, které chcete odebrat, takže níže uvedený kód se nezdaří (bylo by to jednodušší použít dynamicky).

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

Místo toho může být unset () dynamicky použit ve smyčce foreach:

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

Odebrání maticových klíčů zkopírováním pole

Existuje také další praxe, která se ještě nezmínila. Někdy je nejjednodušší způsob, jak se zbavit určitých kláves klíče, jednoduše kopírovat $ 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 ];

Stejný postup se samozřejmě vztahuje na textové řetězce:

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

Odebrat prvek pole na základě klíče:

Použijte funkci unset jako níže:

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

unset($a[1]);

print_r($a);

/*

    Output:

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

*/

Odebrání prvku pole na základě hodnoty:

Použijte funkci array_search k získání klíče elementu a použijte výše uvedený způsob k odstranění prvku pole, jako je následující:

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

*/
4
MahdiY

Použijte následující kód:

$arr = array('orange', 'banana', 'Apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
4
Sunil Kumar Sain
<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

Vytvořte si své pole v proměnné $array a pak tam, kde jsem dal 'prvek, který chcete odstranit' dáte něco jako: "a". A pokud chcete odstranit více položek, pak: "a", "b".

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

Výstup

 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

Pro asociativní pole, s non-celá čísla klíče:\t

Jednoduše řečeno, unset($array[$key]) by fungovalo.

Pro pole s celočíselnými klíči a pokud chcete zachovat klíče:

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

    unset($array[2]);
    $array = array_values($array);
    
  2. array_splice($array, 2, 1);

2
Rahul Patel

Dva způsoby odstranění první položky pole s udržením pořadí indexu a také pokud neznáte klíčový název první položky.

Řešení č. 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);

Řešení č. 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]);

Pro tato ukázková data:

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

Musíte mít tento výsledek:

array(2) {
  [20]=>
  string(1) "b"
  [30]=>
  string(1) "c"
}
2
Nabi K.A.Z.

Použijte pole array_search pro získání klíče a jeho odstranění pomocí unset, pokud bylo nalezeno:

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

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

1
Wakar Ahmad Khan

To může pomoci ...

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

Výsledkem bude:

Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )
1
Klajdi Dosti

unset nezmění index, ale array_splice provede:

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

Pokud znáte index:

$arr = ['a', 'b', 'c'];
$index = 0;

unset($arr[$index]);  // result: $arr = ['b', 'c']

Pokud index neznáte, musíte nejprve hledat hodnotu:

$arr = ['a', 'b', 'c'];
$index = array_search('a',$arr);

unset($arr[$index]);  // result: $arr = ['b', 'c']
0
Ahmad Mobaraki

Proměnný obsah můžeme upravit pomocí odkazu foreach:

<?php
    // Remove all elements in the array
    foreach ($array as &$arr) {
        $arr = null;
    }
0
Pascal Tovohery
$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

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

print_r($arrayName);
0
Javed Khan

Tento úkol lze provést dvěma způsoby: unset () a array_splice ()

Předpokládejme dvě pole:

$array_1 = array('a'=>'One', 'b'=>'Two', 'c'=>'Three');

$array_2 = array('Red', 'Yellow', 'White', 'Black', 'Green');

S odemčeno ()

syntax - unset(array_element)

unset($array_1['a']); // Any valid key
unset($array_2[0]); // Any valid index
  • po odstranění prvku pole se index pole nezmění

S pole 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
  • Všechny elementy pole se po odstranění elementu z pole reindexují
0
Mohammad Wasim

Můžete jednoduše použít unset() k vymazání pole.

Nezapomeňte, že po funkci foreach musí být pole zrušeno.

0
Drake Boein