Löschen eines Elements aus einem Array in PHP

2514

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.

Ben
quelle
14
Ich würde nicht sagen, dass Konrad die einfachste Antwort auf das angegebene Problem ist. Mit unset()den Iterationen über das Array wird der entfernte Wert nicht mehr enthalten. OTOH, es ist wahr, dass Stevan Antwort reichlich ist und tatsächlich die Antwort war, nach der ich gesucht habe - aber nicht die OP :)
brandizzi
32
@danip Das einfache Auffinden im Handbuch schließt eine Frage zu StackOverflow nicht aus. Wenn es sich bei der Frage um eine doppelte StackOverflow-Frage handelt, gehört sie möglicherweise nicht hierher. StackOverflow ist ein guter Ort, um Antworten zu finden, bevor Sie im Handbuch nachsehen.
Dan Nissenbaum
5
@unset ($ array [$ key]); $ array = array_values ​​($ array);
Trojaner
Verwandte Frage zum Entfernen dieser in einer foreach-Schleife: stackoverflow.com/questions/1949259/…
Legolas
Wenn Sie Schlüssel aus dem Array des Arrays ( assoziatives
Somnath Muluk

Antworten:

2871

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.

Rizier123
quelle
25
@AlexandruRada Nein, du hast gesagt "benutze das nicht" - und das ist nur Unsinn. Sie können diese Methode sicher verwenden, wenn Sie ein Array als das behandeln, was es ist - ein Wörterbuch. Nur wenn Sie aufeinanderfolgende numerische Indizes erwarten, müssen Sie etwas anderes verwenden.
Konrad Rudolph
2
@Alexander Verwenden Sie array_splice, wie in den anderen Antworten beschrieben.
Konrad Rudolph
1
@AlexandruRada Es gibt keine Möglichkeit , können Sie haben , array (3) { [0]=>int(0) ...wenn Sie unset($x[2])von $x = array(1, 2, 3, 4);Ergebnis muss sein var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }(es war wahrscheinlich Tippfehler)
inemanja
5
unsetkann mehrere Argumente haben : void unset ( mixed $var [, mixed $... ] ).
14онстантин Ван
3
array_filter ist auch eine praktikable Methode. Besonders gut, wenn Sie das Array nicht mutieren möchten, es aber auch nicht neu indizieren, was ein Problem mit json_encode sein kann. php.net/manual/en/function.json-encode.php#94157
dotnetCarpenter
1358

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)
} */
Stefan Gehrig
quelle
42
Wenn Sie array_splice () verwenden, müssen Sie den OFFSET kennen, nicht den Schlüssel, sondern den Offset (!) Des Elements, das Sie entfernen möchten
Tom
18
@ Tom: Für ein reguläres Array (das kontinuierlich durch Ganzzahlen indiziert ist) ist der Offset der Index. Hier array_splicekann (unter anderem) Sinn machen.
Stefan Gehrig
5
Ja natürlich, aber nur etwas, an das Sie sich erinnern sollten, wenn Sie das Array manipulieren, bevor Sie Splice verwenden
Tom
4
Array_splice ist nur ein grundlegender Test zum Löschen einer Tonne Elemente aus einem riesigen Array und scheint viel schneller und weniger speicherintensiv zu sein. Dies stimmt mit dem überein, was ich erwarten würde: array_values ​​() scheint eine Kopie des Arrays zu erstellen, während array_splice an Ort und Stelle funktioniert.
Doug Kavendek
4
array_values ​​ist ein nützlicher Ansatz, wenn Sie Elemente in einer Schleife entfernen und möchten, dass die Indizes konsistent sind, diese aber nach der Schleife komprimieren möchten.
Rorrik
370
  // 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
)
Marcel Cozma
quelle
$ get_merged_values ​​= array_merge ($ data ['res'], $ data ['check_res']); wenn ich diesen print_r drucke ($ get_merged_values); Es wird Folgendes angezeigt. Array ([0] => Array ([menu_code] => 2 [menu_name] => Plant [menu_order_no] => 1) [1] => Array ([menu_code] => 3 [menu_name] => Zeile [menu_order_no] => 2)) Aber ich muss die Werte von menu_code und menu_name mit $ get_merged_values ​​['menu_code'] bzw. $ get_merged_values ​​['menu_name'] abrufen, anstatt $ get_merged_values ​​[0] [menu_code], $ get_merged_values ​​[0] zu verwenden ] [Menüname]. Bitte helfen Sie mir, wie das geht.
Herz-Hacker
203
$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}
Liamvictor
quelle
4
Es wäre gut zu verdeutlichen, dass diese Antwort zum Löschen eines Elements dient, wenn Sie den Wert kennen, aber nicht den Schlüssel. Beachten Sie, dass nur die ERSTE Instanz des Werts gelöscht wird. finden alle Schlüssel für einen Wert, verwenden array_keys
ToolmakerSteve
84
unset($array[$index]);
Eran Galperin
quelle
65

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.

Robin Nixon
quelle
64

Auch für ein benanntes Element:

unset($array["elementName"]);
DefenestrationDay
quelle
$a = array("A"=>1, "B"=>2, "C"=>"a"); print_r($a); unset($a["B"]); print_r($a); gibt (formatiert): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
DefenestrationDay
Es scheint, dass Sie Array-Elemente, die durch eine Zeichenfolge indiziert wurden, nicht deaktivieren können (generiert "Schwerwiegender Fehler: Zeichenfolgen-Offsets können nicht deaktiviert werden"). Ich glaube nicht, dass dies immer der Fall war, aber sicherlich ab PHP 5.3.10 und wahrscheinlich früher
carpii
6
@carpii PHP kann Elemente aus einem assoziativen Array entfernen. Der schwerwiegende Fehler wird verursacht, wenn Sie versuchen, unset ($ var ['key']) für eine Zeichenfolge anstelle eines Arrays zu verwenden. Beispiel: $ array = array ('test' => 'value', 'another' => ' Wert', ); nicht gesetzt ($ array ['test']); // Entfernt das "test" -Element wie erwartet aus dem Array $ array = 'test'; nicht gesetzt ($ array ['test']); // Wirft wie erwartet "
Jimbo
Hier müssen Sie den Schlüsselnamen kennen, es ist besser: stackoverflow.com/a/52826684/1407491
Nabi KAZ
33

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
KTAnj
quelle
1
Das array_shiftindiziert die Schlüsselelemente neu, wenn es eine Ganzzahl ist, also ist es schlecht, also können Sie dies verwenden: stackoverflow.com/a/52826684/1407491
Nabi KAZ
33
<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Ausgabe:

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

fruit1
Saurabh Chandra Patel
quelle
14
Beachten Sie, dass array_shiftnur das erste Element im Array gelöscht werden kann. Verwenden Sie array_popdiese Option ebenfalls , um das letzte Element im Array zu löschen.
Jasir
1
Die Antwort gilt nur für das erste Element eines Arrays und beantwortet nicht die allgemeine Frage.
sweisgerber.dev
@sebweisgerber du hast recht, aber ich denke nicht, dass das falsch ist und muss diese ans abstimmen. Die Frage ist, ein Element zu löschen, ohne eine Position zu erwähnen.
Saurabh Chandra Patel
27

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.

Mugoma J. Okomba
quelle
21

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']]
spyle
quelle
20

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)
John Slegers
quelle
19

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 ) 
Simon
quelle
Warum wird das so unterschätzt?
Fr0zenFyr
19

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();
?>
Ankit Aggarwal
quelle
17
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}
GigolNet Guigolachvili
quelle
12

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

Ahmad Mobaraki
quelle
1
Wird der Wert nicht gefunden, wird das erste Element entfernt. füge einen Test für das nicht gesetzte hinzu: if ($ index! == false) unset ($ arr [$ index]);
MyRealNameIsBlaze
@MyRealNameIsBlaze danke, behoben
Ahmad Mobaraki
9

Lösungen:

  1. Verwenden Sie unset (), um ein Element zu löschen :
unset($array[3]);
unset($array['foo']);
  1. Verwenden Sie auch unset (), um mehrere nicht zusammenhängende Elemente zu löschen :
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. 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 .

Star
quelle
8

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
)
Tebe
quelle
Wofür wird array_filterverwendet?
David
um falsche Elemente zu entfernen
Tebe
8

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.

Oxydel
quelle
8

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);
msvairam
quelle
7
<?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".

Joshua Charles Pickwell
quelle
7

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

quelle
6

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' ]
Kristoffer Bohmann
quelle
6

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
        )

*/
MahdiY
quelle
6

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"
}
Nabi KAZ
quelle
5

Verwenden Sie den folgenden Code:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
Jens Erat
quelle
4
php5: Durch einfaches Ausführen array_pop($arr)wird der endgültige Eintrag entfernt. Kein `=` benötigt.
Chris K
5
<?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 )
UMAR FAROOQUE KHAN
quelle
4

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

Rahul Patel
quelle
2

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 )
Klajdi Dosti
quelle
2
$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

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

print_r($arrayName);
Javed Khan
quelle