remove - php unset object




PHP: Ein Element aus einem Array löschen (20)

nicht gesetzt, ändern Sie den Index nicht, aber array_splice tut dies

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

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 wäre, würde es tun, aber anscheinend funktioniert es nicht.


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 array_splice() 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)

Angenommen, Sie haben ein solches Array:

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

So löschen Sie storage :

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

Und du bekommst:

Array
(
    [user_id] => 193
)

Auch für ein benanntes Element:

unset($array["elementName"]);

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 Arrayelement

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

Wenn Sie den Wert haben und den Schlüssel zum Löschen des Elements nicht kennen, können Sie array_search() , um den Schlüssel array_search() .

unset() Methode

Beachten 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 array_values() verwenden. array_values() werden alle Schlüssel in numerische Aufzählungsschlüssel umgewandelt, die bei 0 beginnen.

Code

<?php

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

?>

Ausgabe

Array (
    [0] => a
    [2] => c
)

array_splice() -Methode

Wenn Sie array_splice() die Schlüssel automatisch neu indiziert. Die assoziativen Schlüssel ändern sich jedoch nicht im Gegensatz zu array_values() wodurch alle Schlüssel in numerische Schlüssel umgewandelt werden.

Auch array_splice() benötigt den Offset, nicht den Schlüssel! als zweiter Parameter.

Code

<?php

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

?>

Ausgabe

Array (
    [0] => a
    [1] => c
)

array_splice() dem Array als Referenz. Dies bedeutet, dass Sie die Rückgabewerte dieser Funktionen nicht wieder dem Array zuweisen möchten.

Löschen Sie mehrere Array-Elemente

Wenn Sie mehrere Array-Elemente löschen möchten und nicht mehrmals array_diff() oder array_diff_key() aufrufen möchten, können Sie die Funktionen array_diff() oder array_diff_key() je nachdem, ob Sie die Werte oder die Schlüssel der Elemente kennen Sie möchten löschen.

array_diff() -Methode

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

Code

<?php

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

?>

Ausgabe

Array (
    [1] => b
)

Methode array_diff_key()

Wenn 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() . Und auch hier ändern sich die Schlüssel nicht.

Code

<?php

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

Ausgabe

Array (
    [1] => b
)

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


Es sollte beachtet werden, dass unset() Indizes unberührt lässt, was Sie erwarten würden, wenn Sie String-Indizes (Array als Hashtabelle) verwenden, aber bei ganzzahligen indizierten Arrays recht überraschend sein kann:

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

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

Folgen Sie den Standardfunktionen

i)

$Array = array("test1","test2","test3","test3");

unset($Array[2]);

ii)

$Array = array("test1","test2","test3","test3");

array_pop($Array);

iii)

$Array = array("test1","test2","test3","test3");

array_splice($Array,1,2);

iv)

$Array = array("test1","test2","test3","test3");

array_shift($Array);

Ich möchte nur sagen, dass ich ein bestimmtes Objekt mit variablen Attributen hatte (es war im Wesentlichen eine Zuordnung einer Tabelle und ich habe die Spalten in der Tabelle geändert, sodass die Attribute im 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 Zweck von $ -Feldern bestand nur aus dem Grund, dass ich nicht überall im Code nachsehen muss, wenn sie geändert werden. Ich schaue nur den Anfang der Klasse an und ändere die Liste der Attribute und den Inhalt des $ -Feld- Arrays entsprechend neue Attribute.

Ich brauchte eine Weile, um das herauszufinden. Hoffe das kann jemandem helfen.


Um eine Suche zu vermeiden, kann man mit array_diff :

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


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

Dies zeigt Folgendes an:

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.


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

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

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 [array_filter][1] . 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']]

Entfernen Sie ein Arrayelement basierend auf dem 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 Arrayelement basierend auf Wert:

Verwenden array_search Funktion array_search , um den Elementschlüssel array_search , und entfernen Sie wie oben beschrieben das 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
)

*/

Lösungen:

  1. Um ein Element zu löschen, verwenden Sie unset() :
unset($array[3]);
unset($array['foo']);
  1. Um mehrere nicht zusammenhängende Elemente zu löschen, verwenden Sie auch unset() :
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. 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 Zuordnung von '' zum Element. Der erste besagt, dass This doesn't exist anymore, während der zweite besagt, dass The This still exists, but its value is the empty string.

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 ein Element unset() , passt PHP das Array so an, 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 new element
$animals[ ] = 'gnu'; // add 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 array_values() :

$animals = array_values($animals);

Alternativ array_splice() Arrays automatisch neu, 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 () bzw. array_pop () .


$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // here is key to be delete
echo '<br>';
array_values($x);
var_dump($x);


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

Ausgänge

Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => indigo
)

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

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

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

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






arrays