Gibt es eine einfache Möglichkeit, ein Element mit PHP aus einem Array zu löschen, sodass foreach ($array)dieses Element nicht mehr enthalten ist?

Ich dachte, dass das Einstellen es nulltun würde, aber anscheinend funktioniert es nicht.

Es gibt verschiedene Möglichkeiten, ein Array-Element zu löschen, wobei einige für bestimmte Aufgaben nützlicher sind als andere.

Löschen Sie ein Array-Element

Wenn Sie nur ein Array-Element löschen möchten, können Sie unset()oder alternativ verwenden \array_splice().

Auch wenn Sie den Wert haben und den Schlüssel zum Löschen des Elements nicht kennen, können Sie ihn \array_search()zum Abrufen des Schlüssels verwenden.

unset()

Beachten Sie, dass sich unset()die Array-Schlüssel bei Verwendung der Array-Schlüssel nicht ändern / neu indizieren. Wenn Sie die Schlüssel neu indizieren möchten, können Sie \array_values()danach unset()alle Schlüssel ab 0 in numerische Aufzählungsschlüssel konvertieren.

Code

<?php

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

?>

Ausgabe

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

\array_splice() Methode

Wenn Sie \array_splice()die Schlüssel verwenden, werden sie automatisch neu indiziert, aber die assoziativen Schlüssel ändern sich nicht, im Gegensatz dazu \array_values()werden alle Schlüssel in numerische Schlüssel konvertiert.

Auch \array_splice()muss der Offset, nicht der Schlüssel! als zweiter Parameter.

Code

<?php

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

?>

Ausgabe

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

array_splice()gleiche wie unset()nehmen Sie die Anordnung Bezug genommen wird , und das bedeutet , Sie wollen nicht die Rückgabewerte dieser Funktionen auf das Array zurück zuweisen.

Löschen Sie mehrere Array-Elemente

Wenn Sie mehrere Array-Elemente löschen möchten und nicht unset()oder \array_splice()mehrmals aufrufen möchten, können Sie die Funktionen verwenden \array_diff()oder \array_diff_key()abhängig davon, ob Sie die Werte oder die Tasten der Elemente kennen, die Sie löschen möchten.

\array_diff() Methode

Wenn Sie die Werte der Array-Elemente kennen, die Sie löschen möchten, können Sie sie verwenden \array_diff(). Wie zuvor unset()werden die Schlüssel des Arrays nicht geändert / neu indiziert.

Code

<?php

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

?>

Ausgabe

[
    [1] => b
]

\array_diff_key() Methode

Wenn Sie die Schlüssel der Elemente kennen, die Sie löschen möchten, möchten Sie sie verwenden \array_diff_key(). Hier müssen Sie sicherstellen, dass Sie die Schlüssel als Schlüssel im zweiten Parameter und nicht als Werte übergeben. Andernfalls müssen Sie das Array umdrehen \array_flip(). Und auch hier werden sich die Schlüssel nicht ändern / neu indizieren.

Code

<?php

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

Ausgabe

[
    [1] => b
]

Wenn Sie mehrere Elemente mit demselben Wert verwenden unset()oder \array_splice()löschen möchten, können Sie auch \array_keys()alle Schlüssel für einen bestimmten Wert abrufen und anschließend alle Elemente löschen.

Es sollte beachtet werden, dass unset()Indizes unberührt bleiben, was Sie bei der Verwendung von Zeichenfolgenindizes (Array als Hashtabelle) erwarten würden, aber beim Umgang mit ganzzahlig indizierten Arrays ziemlich überraschend sein können:

$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 array_splice()kann verwendet werden , wenn Sie Ihre ganze Zahl Schlüssel normalisieren möchten. Eine andere 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 des obigen Codes:

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
)

Jetzt indiziert array_values ​​() ein numerisches Array schön 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);

Ausgänge

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 ein numerisch indiziertes Array haben, 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);

Dies zeigt Folgendes an:

4
3

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

Auch für ein benanntes Element:

unset($array["elementName"]);

Zerstören Sie 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 neu 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"
}

Pop das Element vom Ende des Arrays - geben Sie 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

Entfernen Sie das erste Element (rot) aus einem Array . - Geben Sie 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 = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Ausgabe:

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

fruit1

Um eine Suche zu vermeiden, kann man herumspielen mit array_diff:

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

In diesem Fall muss man den Schlüssel nicht suchen / benutzen.

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

$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 unsetfür numerische Arrays führt nicht zu einem Fehler, bringt jedoch Ihre Indizes durcheinander:

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

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

Wenn Sie mehrere Elemente aus einem assoziativen Array entfernen müssen, können Sie array_diff_key () verwenden (hier zusammen mit array_flip () verwendet ):

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

unset() zerstört die angegebenen Variablen.

Das Verhalten unset()innerhalb einer Funktion kann variieren, je nachdem, welche Art von Variable Sie zerstören möchten.

Befindet sich eine globalisierte Variable unset()innerhalb einer Funktion, wird nur die lokale Variable zerstört. Die Variable in der aufrufenden Umgebung behält den gleichen Wert wie zuvor, unset()der aufgerufen wurde.

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

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

Die Antwort auf den obigen Code lautet bar .

Zu unset()einer globalen Variablen innerhalb einer Funktion:

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

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

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

Wenn der Index angegeben ist:

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

Wenn der Index NICHT angegeben ist:

$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
   unset($arr[$index]);  // $arr = ['b', 'c']
}

Die ifBedingung ist notwendig, da, wenn sie indexnicht gefunden unset()wird, automatisch das erste Element des Arrays gelöscht wird, was nicht das ist, was wir wollen

Lösungen:

1. Verwenden Sie unset (), um ein Element zu löschen :

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

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

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

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

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, aber einen leeren Wert haben, 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 sagtThis doesn't exist anymore, während der zweite sagtThis still exists, but its value is the empty string.

Wenn Sie mit Zahlen zu tun haben, ist die Zuweisung von 0 möglicherweise die bessere Alternative. Wenn ein Unternehmen die Produktion des Kettenrads XL1000 einstellen würde, würde es sein Inventar aktualisieren mit:

unset($products['XL1000']);

Wenn jedoch vorübergehend keine XL1000-Kettenräder mehr vorhanden waren, aber geplant war, später in dieser Woche eine neue Lieferung aus dem Werk zu erhalten, ist dies besser:

$products['XL1000'] = 0;

Wenn Sie ein Element deaktivieren () , passt PHP das Array so an, dass die Schleife weiterhin korrekt funktioniert. Das Array wird nicht komprimiert, um die fehlenden Löcher zu füllen. Dies ist, was wir meinen, wenn wir sagen, dass alle Arrays assoziativ sind, auch 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 zu einem dicht gefüllten numerischen Array zu komprimieren :

$animals = array_values($animals);

Alternativ indiziert array_splice () Arrays automatisch neu, um zu vermeiden, dass Löcher entstehen:

// 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 weiterhin wahlfreien Zugriff zulassen. Verwenden Sie array_shift () bzw. array_pop () , um das erste oder letzte Element sicher aus einem Array zu entfernen .

Angenommen, Sie haben das folgende Array:

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

Gehen Sie zum Löschen wie storagefolgt vor:

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 (es ordnete im Grunde eine Tabelle zu und ich änderte die Spalten in der Tabelle, sodass auch die Attribute im Objekt, die die Tabelle widerspiegeln, variieren würden):

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 $fieldswar nur, damit ich nicht überall im Code suchen muss, wenn sie geändert werden. Ich schaue nur auf den Anfang der Klasse und ändere die Liste der Attribute und den Inhalt des $ fields- Arrays, um den neuen wiederzugeben Attribute.

Befolgen Sie die 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);

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

Erstellen Sie Ihr Array in der Variablen $arrayund setzen Sie dort, wo ich 'Element, das Sie löschen möchten' platziert habe, etwas wie: "a". Und wenn Sie mehrere Elemente löschen möchten, dann: "a", "b".

Verwenden Sie array_search, um den Schlüssel abzurufen und ihn mit unset zu entfernen, wenn er gefunden wird:

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

unset () mehrere fragmentierte Elemente aus einem Array

Obwohl unset()dies hier bereits mehrfach erwähnt wurde, muss noch erwähnt werden, dass unset()mehrere Variablen akzeptiert werden, wodurch es einfach ist, mehrere nicht zusammenhängende Elemente in einem Vorgang aus einem Array zu löschen:

// 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 Array von Schlüsseln zum Entfernen, daher schlägt der folgende Code fehl (dies hätte es jedoch etwas einfacher gemacht, unset () dynamisch zu verwenden).

$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 noch eine andere Praxis, die noch erwähnt werden muss. Manchmal ist der einfachste Weg, bestimmte Array-Schlüssel loszuwerden, einfach $ array1 in $ array2 zu 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 ];

Offensichtlich 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 Array-Element basierend auf einem Schlüssel:

Verwenden Sie die folgende unsetFunktion:

$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_searchFunktion, um einen Elementschlüssel abzurufen, und entfernen Sie auf die oben beschriebene Weise ein Array-Element wie folgt:

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

*/

Zwei Möglichkeiten zum Entfernen des ersten Elements eines Arrays unter Beibehaltung der Reihenfolge des Index und auch, 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 den folgenden Code:

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

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, unset($array[$key])Würde funktionieren.

Für Arrays mit Ganzzahlschlüsseln und wenn Sie Ihre Schlüssel beibehalten möchten:

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

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

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

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

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

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

print_r($arrayName);