PHP: Löschen Sie ein Element aus einem Array

Es sollte beachtet werden, dass unset() Indizes unberührt lassen wird, was Sie erwarten würden, wenn Sie String-Indizes (Array als Hashtabelle) verwenden. Bei ganzzahligen indizierten Arrays kann dies jedoch ziemlich überraschend sein:

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

So kann array_splice() verwendet werden, wenn Sie Ihre Integer-Schlüssel normalisieren möchten. Eine weitere Option ist die Verwendung von 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)
} */

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

Dies ist die Ausgabe aus dem obigen Code:

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
)

Array_values ​​() indiziert nun ein numerisches Array neu, entfernt jedoch alle Schlüsselzeichenfolgen aus dem Array und ersetzt sie durch Zahlen. Wenn Sie die Schlüsselnamen (Zeichenfolgen) beibehalten oder das Array neu indizieren müssen, wenn alle Schlüssel numerisch sind, verwenden Sie array_merge ():

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

Ausgaben

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

Wenn Sie über ein numerisch indiziertes Array verfügen, in dem alle Werte eindeutig sind (oder nicht eindeutig sind, Sie jedoch alle Instanzen eines bestimmten Werts entfernen möchten), können Sie einfach array_diff () verwenden, um ein übereinstimmendes Element wie folgt zu entfernen:

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

Zum Beispiel:

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

Daraufhin wird Folgendes angezeigt:

4
3

In diesem Beispiel wird das Element mit dem Wert 'Charles' entfernt. Dies kann durch die Aufrufe von sizeof () verifiziert werden, die eine Größe von 4 für das ursprüngliche Array und 3 nach dem Entfernen melden.

Auch für ein benanntes Element:

unset($array["elementName"]);

Zerstöre ein einzelnes Element eines Arrays

unset()

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

Die Ausgabe wird sein:

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

Wenn Sie das Array erneut indizieren müssen:

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

Dann wird die Ausgabe sein:

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

Popup des Elements vom Ende des Arrays - gibt den Wert des entfernten Elements zurück

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

Die Ausgabe wird sein

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

Entfernt das erste Element (rot) aus einem Array , - gibt den Wert des entfernten Elements zurück

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

Die Ausgabe wird sein:

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

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

    echo $fruit;
?>

Ausgabe: 

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

fruit1

Um eine Suche zu vermeiden, kann mit array_diff herumgespielt werden:

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

In diesem Fall muss der Schlüssel nicht gesucht/verwendet werden.

unset() zerstört die angegebenen Variablen.

Das Verhalten von unset() innerhalb einer Funktion hängt von dem Typ der Variablen ab, die Sie zerstören möchten.

Wenn sich eine globalisierte Variable in einer Funktion unset() befindet, wird nur die lokale Variable zerstört. Die Variable in der aufrufenden Umgebung behält den gleichen Wert wie vor dem Aufruf von unset().

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

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

Die Antwort des obigen Codes lautet bar .

unset() eine globale Variable innerhalb einer Funktion:

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

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

Wenn Sie mehrere Werte in einem Array löschen müssen und die Einträge in diesem Array Objekte oder strukturierte Daten sind, ist [array_filter][1] die beste Wahl. Die Einträge, die von der Rückruffunktion einen Wert zurückgeben, werden beibehalten. 

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

Assoziative Arrays

Verwenden Sie für assoziative Arrays unset :

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

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

Numerische Arrays

Verwenden Sie für numerische Arrays array_splice :

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

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

Hinweis

Die Verwendung von unset für numerische Arrays führt nicht zu einem Fehler, aber die Indizes werden durcheinander gebracht:

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

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

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

Wenn Sie mehrere Elemente aus einem assoziativen Array entfernen müssen, können Sie array_diff_key () verwenden (hier verwendet mit 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);

Ausgabe:

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

Folgen Sie den Standardfunktionen:

ich)

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

Angenommen, Sie haben das folgende Array:

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

Um storage zu löschen, machen Sie folgendes:

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

Und du bekommst:

Array
(
    [user_id] => 193
)

Ich möchte nur sagen, dass ich ein bestimmtes Objekt mit variablen Attributen hatte (im Wesentlichen wurde eine Tabelle zugeordnet, und ich habe die Spalten in der Tabelle geändert, sodass die Attribute in dem Objekt, die die Tabelle widerspiegeln, ebenfalls variieren könnten):

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

Der ganze Zweck von $fields war nur, also muss ich nicht überall im Code nachsehen, wenn er geändert wird. Ich schaue nur den Anfang der Klasse an und ändere die Liste der Attribute und das $ -Feld -Array Inhalt, um die neuen Attribute widerzuspiegeln.

Lösungen:

1. Um ein Element zu löschen, verwenden Sie unset () :

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

2. Um mehrere nicht zusammenhängende Elemente zu löschen, verwenden Sie auch unset () :

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

3. Um mehrere zusammenhängende Elemente zu löschen, verwenden Sie array_splice () :

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

Weitere Erklärung:

Mit diesen Funktionen werden alle Verweise auf diese Elemente aus PHP entfernt. Wenn Sie einen Schlüssel im Array behalten möchten, der jedoch einen leeren Wert enthält, weisen Sie dem Element die leere Zeichenfolge zu:

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

Neben der Syntax gibt es einen logischen Unterschied zwischen der Verwendung von unset () und der Zuweisung von '' zum Element. Der erste sagt This doesn't exist anymore,, während der zweite This still exists, but its value is the empty string. sagt

Wenn Sie mit Zahlen zu tun haben, kann die Zuweisung von 0 die bessere Alternative sein. Wenn also ein Unternehmen die Produktion des Kettenrads XL1000 stoppte, würde es seinen Bestand mit folgenden Informationen aktualisieren:

unset($products['XL1000']);

Wenn der XL1000-Zahnkranz jedoch vorübergehend ausgeht, aber später in der Woche eine neue Lieferung aus dem Werk erhalten wollte, ist dies besser:

$products['XL1000'] = 0;

Wenn Sie unset () ein Element verwenden, stellt PHP das Array so ein, dass die Schleife immer noch korrekt funktioniert. Das Array wird nicht komprimiert, um die fehlenden Löcher zu füllen. Das meinen wir, wenn wir sagen, dass alle Arrays assoziativ sind, selbst wenn sie numerisch erscheinen. Hier ist ein Beispiel:

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

Verwenden Sie array_values ​​() , um das Array in ein dicht gefülltes numerisches Array zu komprimieren.

$animals = array_values($animals);

Alternativ werden array_splice () Arrays automatisch neu indexiert, um Löcher zu vermeiden:

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

Dies ist nützlich, wenn Sie das Array als Warteschlange verwenden und Elemente aus der Warteschlange entfernen möchten, während Sie den wahlfreien Zugriff zulassen. Um das erste oder letzte Element sicher aus einem Array zu entfernen, verwenden Sie array_shift () und array_pop () .

unset () mehrere fragmentierte Elemente aus einem Array

Während unset() hier mehrfach erwähnt wurde, muss noch erwähnt werden, dass unset() mehrere Variablen akzeptiert, wodurch das einfache Löschen mehrerer nicht zusammenhängender Elemente aus einem Array in einem Vorgang möglich ist:

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

unset () dynamisch

unset () akzeptiert kein zu entfernendes Array von Schlüsseln, daher schlägt der folgende Code fehl (es hätte jedoch die dynamische Verwendung von unset () etwas erleichtert).

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

Stattdessen kann unset () dynamisch in einer foreach-Schleife verwendet werden:

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

Entfernen Sie die Array-Schlüssel, indem Sie das Array kopieren

Es gibt auch noch eine andere Praxis, die noch erwähnt werden muss .. Manchmal ist es am einfachsten, bestimmte Array-Schlüssel loszuwerden, indem Sie einfach $ array1 in $ array2 kopieren.

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

Selbstverständlich gilt die gleiche Vorgehensweise für Textzeichenfolgen:

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

Entfernen Sie ein Arrayelement basierend auf einem Schlüssel:

Verwenden Sie die unset-Funktion wie folgt:

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

unset($a[1]);

print_r($a);

/*

    Output:

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

*/

Entfernen Sie ein Array-Element basierend auf dem Wert:

Verwenden Sie die array_search-Funktion, um einen Elementschlüssel abzurufen, und entfernen Sie wie oben beschrieben ein Array-Element:

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

*/

Verwenden Sie den folgenden Code:

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

Erstellen Sie Ihr Array in der Variablen $array und dann, wo ich "Element, das Sie löschen möchten" eingefügt haben, setzen Sie etwas wie "a". Und wenn Sie mehrere Elemente löschen möchten, dann: "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);
?>

Ausgabe

 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 )

Für assoziative Arrays mit nicht ganzzahligen Schlüsseln:

Einfach würde unset($array[$key]) funktionieren.

Für Arrays mit Integer-Schlüsseln und wenn Sie Ihre Schlüssel pflegen möchten:

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

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

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

Es gibt zwei Möglichkeiten, das erste Element eines Arrays mit der Reihenfolge des Indexes zu entfernen und wenn Sie den Schlüsselnamen des ersten Elements nicht kennen.

Lösung 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);

Lösung 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]);

Für diese Beispieldaten:

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

Sie müssen dieses Ergebnis haben:

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

Verwenden Sie array_search, um den Schlüssel abzurufen, und entfernen Sie ihn mit unset, falls gefunden:

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

Das kann helfen ...

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

Das Ergebnis wird sein:

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

unset ändert den Index nicht, aber array_splice tut:

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

Wenn Sie den Index kennen:

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

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

Wenn Sie den Index nicht kennen, müssen Sie zuerst den Wert suchen:

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

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

wenn Sie ein bestimmtes Objekt eines Arrays durch Verweis auf dieses Objekt entfernen möchten, haben Sie folgende Möglichkeiten:

unset($array[array_search($object,$array)]);

Beispiel:

<?php
class Foo
{
    public $id;
    public $name;
}

$foo1 = new Foo();
$foo1->id = 1;
$foo1->name = 'Name1';

$foo2 = new Foo();
$foo2->id = 2;
$foo2->name = 'Name2';

$foo3 = new Foo();
$foo3->id = 3;
$foo3->name = 'Name3';


$array = array($foo1,$foo2,$foo3);
unset($array[array_search($foo2,$array)]);

echo '<pre>';
var_dump($array);
echo '</pre>';
?>

Ergebnis:

array(2) {
[0]=>
    object(Foo)#1 (2) {
        ["id"]=>
        int(1)
        ["name"]=>
        string(5) "Name1"
    }
[2]=>
    object(Foo)#3 (2) {
        ["id"]=>
        int(3)
        ["name"]=>
        string(5) "Name3"
    }
}

Beachten Sie, dass das Objekt, wenn es mehrmals vorkommt, nur beim ersten Auftreten entfernt wird!

Wir können Variableninhalt mit einer Referenz ändern, indem Sie foreach verwenden:

<?php
    // Remove all elements in the array
    foreach ($array as &$arr) {
        $arr = null;
    }

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

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

print_r($arrayName);

Es gibt zwei Methoden, um diese Aufgabe auszuführen: unset () und array_splice ()

Nehmen wir zwei Arrays an:

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

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

Mit unset ()

syntax - unset(array_element)

unset($array_1['a']); // Any valid key
unset($array_2[0]); // Any valid index

• nach dem Entfernen eines Arrayelements ändert sich der Arrayindex nicht

Mit 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

• Alle Array-Elemente werden nach dem Entfernen eines Elements aus dem Array neu indiziert

Sie können einfach unset() verwenden, um ein Array zu löschen.

Denken Sie daran, dass ein Array nach der foreach-Funktion deaktiviert werden muss.