Gibt es eine einfache Möglichkeit, ein Element mit PHP
aus einem Array zu löschen, sodass foreach ($array)
dieses Element nicht mehr enthält?
Ich dachte, dass es auf null
eingestellt wäre, 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.
Wenn Sie nur ein Array-Element löschen möchten, können Sie \unset()
oder alternativ \array_splice()
verwenden.
Wenn Sie den Wert haben und den Schlüssel zum Löschen des Elements nicht kennen, können Sie \array_search()
verwenden, um den Schlüssel zu erhalten.
\unset()
MethodeBeachten Sie, dass sich die Array-Schlüssel bei Verwendung von \unset()
nicht ändern bzw. neu indexieren. Wenn Sie die Schlüssel neu indizieren möchten, können Sie \array_values()
nach \unset()
verwenden, wodurch alle Schlüssel in numerische Aufzählungsschlüssel ab 0 konvertiert werden.
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()
MethodeWenn Sie \array_splice()
verwenden, werden die Schlüssel automatisch neu indiziert. Die assoziativen Schlüssel ändern sich jedoch nicht, im Gegensatz zu \array_values()
, das alle Schlüssel in numerische Schlüssel konvertiert.
Auch \array_splice()
benötigt den Versatz, nicht den 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()
wie \unset()
nimmt das Array als Referenz, und Sie möchten die Rückgabewerte dieser Funktionen nicht wieder dem Array zuweisen.
Wenn Sie mehrere Array-Elemente löschen möchten und \unset()
oder \array_splice()
nicht mehrfach aufrufen möchten, können Sie die Funktionen \array_diff()
oder \array_diff_key()
verwenden, je nachdem, ob Sie die Werte oder die Schlüssel der Elemente kennen, die Sie löschen möchten.
\array_diff()
MethodeWenn Sie die Werte der Arrayelemente kennen, die Sie löschen möchten, können Sie \array_diff()
verwenden. Wie zuvor bei \unset()
werden die Schlüssel des Arrays nicht geändert.
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()
MethodeWenn Sie die Schlüssel der Elemente kennen, die Sie löschen möchten, verwenden Sie \array_diff_key()
. Hier müssen Sie sicherstellen, dass Sie die Schlüssel als Schlüssel im zweiten Parameter übergeben und nicht als Werte. Andernfalls müssen Sie das Array mit \array_flip()
umdrehen. Und auch hier ändern sich die Schlüssel nicht.
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 \unset()
oder \array_splice()
verwenden möchten, um mehrere Elemente mit demselben Wert zu löschen, können Sie \array_keys()
verwenden, um alle Schlüssel für einen bestimmten Wert abzurufen und alle Elemente zu löschen.
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']]
Verwenden Sie für assoziative Arrays unset
:
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
Verwenden Sie für numerische Arrays array_splice
:
$arr = array(1, 2, 3);
array_splice($arr, 1, 1);
// RESULT: array(0 => 1, 1 => 3)
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:
unset($array[3]); unset($array['foo']);
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
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 () .
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 () 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 ]
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' ]
Verwenden Sie die unset
-Funktion wie folgt:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
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:
$array = [ 'mango', 'red', 'orange', 'grapes'];
unset($array[2]);
$array = array_values($array);
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.
// 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);
// 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]);
}
$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);
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
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
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.