Is er een gemakkelijke manier om met PHP een element uit een array te verwijderen, zodat foreach ($array)dat element niet meer bevat?
Ik dacht dat het zou lukken om het op nullin te stellen, maar blijkbaar werkt het niet.
Antwoord 1, autoriteit 100%
Er zijn verschillende manieren om een array-element te verwijderen, waarbij sommige nuttiger zijn voor sommige specifieke taken dan andere.
Een enkel array-element verwijderen
Als u slechts één array-element wilt verwijderen, kunt u unset()of als alternatief \array_splice().
Als je de waarde kent en niet de sleutel weet om het element te verwijderen, kun je \array_search()om de sleutel te krijgen. Dit werkt alleen als het element niet meer dan één keer voorkomt, aangezien \array_searchalleen de eerste treffer retourneert.
unset()
Houd er rekening mee dat wanneer u unset()gebruikt, de array-sleutels niet veranderen. Als u de sleutels opnieuw wilt indexeren, kunt u \array_values()na unset(), waarmee alle sleutels worden geconverteerd naar numeriek opgesomde sleutels vanaf 0.
Code:
$array = [0 => "a", 1 => "b", 2 => "c"];
unset($array[1]);
// ↑ Key which you want to delete
Uitvoer:
[
[0] => a
[2] => c
]
\array_splice()methode
Als u \array_splice()gebruikt, worden de sleutels automatisch opnieuw geïndexeerd, maar de associatieve sleutels veranderen niet — in tegenstelling tot \array_values(), die wel converteer alle toetsen naar numerieke toetsen.
\array_splice()heeft de offsetnodig, niet de sleutel, als de tweede parameter.
Code:
$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
// ↑ Offset which you want to delete
Uitvoer:
[
[0] => a
[1] => c
]
array_splice(), hetzelfde als unset(), neem de array als referentie. U wijst de geretourneerde waarden van die functies niet terug aan de array.
Meerdere array-elementen verwijderen
Als u meerdere array-elementen wilt verwijderen en niet meerdere keren unset()of \array_splice()wilt aanroepen, kunt u de functies \array_diff()of \array_diff_key()afhankelijk van of je de waarden of sleutels kent van de elementen die je wilt verwijderen.
\array_diff()methode
Als u de waarden kent van de array-elementen die u wilt verwijderen, kunt u \array_diff()gebruiken. Zoals eerder met unset()zal het de sleutels van de array niet veranderen.
Code:
$array = [0 => "a", 1 => "b", 2 => "c", 3 => "c"];
$array = \array_diff($array, ["a", "c"]);
// └────────┘
// Array values which you want to delete
Uitvoer:
[
[1] => b
]
\array_diff_key()methode
Als u de sleutels kent van de elementen die u wilt verwijderen, dan wilt u \array_diff_key()gebruiken. U moet ervoor zorgen dat u de sleutels als sleutels in de tweede parameter doorgeeft en niet als waarden. Sleutels worden niet opnieuw geïndexeerd.
Code:
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
// ↑ ↑
// Array keys which you want to delete
Uitvoer:
[
[1] => b
]
Als u unset()of \array_splice()wilt gebruiken om meerdere elementen met dezelfde waarde te verwijderen, kunt u \array_keys()om alle sleutels voor een specifieke waarde te krijgen en verwijder vervolgens alle elementen.
Antwoord 2, autoriteit 43%
Opgemerkt moet worden dat unset()indexen onaangeroerd houdt, wat wat je zou verwachten bij het gebruik van stringindexen (array als hashtabel), maar het kan behoorlijk verrassend zijn als je te maken hebt met integer geïndexeerde arrays:
$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)
} */
dus array_splice()kan worden gebruikt als u u wilt normaliseren Integer-sleutels. Een andere optie gebruikt array_values()na 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)
} */
3, Autoriteit 12%
// 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);
Dit is de uitvoer van de hierboven 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
)
Nu zal array_values() een numerieke array netjes herindexeren, maar het zal alle key strings uit de array verwijderen en ze vervangen door getallen. Als u de sleutelnamen (strings) wilt behouden of de array opnieuw wilt indexeren als alle sleutels numeriek zijn, gebruikt u array_merge():
$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);
Uitgangen
Array
(
[0] => blue
[1] => green
[2] => green
[3] => orange
[4] => indigo
)
Antwoord 4, autoriteit 7%
$key = array_search($needle, $array);
if ($key !== false) {
unset($array[$key]);
}
Antwoord 5, autoriteit 3%
unset($array[$index]);
Antwoord 6, autoriteit 2%
Als je een numeriek geïndexeerde array hebt waar alle waarden uniek zijn (of ze zijn niet-uniek maar je wilt alle instanties van een bepaalde waarde verwijderen), dan kun je eenvoudig array_diff() gebruiken om een overeenkomend element te verwijderen, zoals dit :
$my_array = array_diff($my_array, array('Value_to_remove'));
Bijvoorbeeld:
$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);
Dit geeft het volgende weer:
4
3
In dit voorbeeld wordt het element met de waarde ‘Charles’ verwijderd, zoals kan worden geverifieerd door de sizeof()-aanroepen die een grootte van 4 rapporteren voor de initiële array en 3 na de verwijdering.
Antwoord 7, autoriteit 2%
Ook voor een benoemd element:
unset($array["elementName"]);
Antwoord 8
Vernietig een enkel element van een array
unset()
$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);
De uitvoer zal zijn:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[3]=>
string(1) "D"
[4]=>
string(1) "E"
}
Als u de array opnieuw moet indexeren:
$array1 = array_values($array1);
var_dump($array1);
De uitvoer is dan:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
Plaats het element van het einde van de array– retourneer de waarde van het verwijderde element
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
De uitvoer zal zijn
Array
(
[0] => orange
[1] => banana
[2] => apple
)
Last Fruit: raspberry
Verwijder het eerste element (rood) uit een array, – retourneer de waarde van het verwijderde element
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);
De uitvoer zal zijn:
Array
(
[b] => green
[c] => blue
)
First Color: red
Antwoord 9
<?php
$stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Uitvoer:
[
[0] => fruit2
[1] => fruit3
[2] => fruit4
]
fruit1
Antwoord 10
Om te voorkomen dat je moet zoeken, kun je wat spelen met array_diff:
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
In dit geval hoeft men de sleutel niet te zoeken/gebruiken.
Antwoord 11
Als de index is opgegeven:
$arr = ['a', 'b', 'c'];
$index = 0;
unset($arr[$index]); // $arr = ['b', 'c']
Als de index NIET is opgegeven:
$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
unset($arr[$index]); // $arr = ['b', 'c']
}
De voorwaarde ifis noodzakelijk
want als indexniet wordt gevonden, wordt unset()automatisch verwijderd
het eerste element van de array dat niet is wat we willen.
Antwoord 12
Als je meerdere waarden in een array moet verwijderen en de items in die array zijn objecten of gestructureerde gegevens, dan is [array_filter][1]de beste keuze. De vermeldingen die een true van de callback-functie retourneren, blijven behouden.
$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']]
Antwoord 13
Associatieve arrays
Gebruik voor associatieve arrays unset:
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
Numerieke arrays
Gebruik voor numerieke arrays array_splice:
$arr = array(1, 2, 3);
array_splice($arr, 1, 1);
// RESULT: array(0 => 1, 1 => 3)
Opmerking
Gebruik unsetVoor numerieke arrays produceert geen fout, maar het zal uw indexen verpesten:
$arr = array(1, 2, 3);
unset($arr[1]);
// RESULT: array(0 => 1, 2 => 3)
14
Als u meerdere elementen van een associatieve array wilt verwijderen, kunt u array_diff_key () (hier gebruikt met 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);
Uitgang:
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
15
unset()vernietigt de opgegeven variabelen.
Het gedrag van unset()binnenkant van een functie kan variëren afhankelijk van het type variabele dat u probeert te vernietigen.
Als een geglobaliseerde variabele unset()binnenkant van een functie, is alleen de lokale variabele vernietigd. De variabele in de oproepomgeving behoudt dezelfde waarde als vóór unset()werd genoemd.
<?php
function destroy_foo()
{
global $foo;
unset($foo);
}
$foo = 'bar';
destroy_foo();
echo $foo;
?>
Het antwoord van de bovenstaande code is Bar .
Naar unset()A GLOBAL-variabele binnenkant van een functie:
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar = "something";
foo();
?>
16
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
17
oplossingen:
- Om één element te verwijderen, gebruikt u unset () :
unset($array[3]); unset($array['foo']);
- Om meerdere niet-bontige elementen te verwijderen, gebruikt u ook unset () :
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
- Om meerdere aangrenzende elementen te verwijderen, gebruikt u array_splice () :
array_splice($array, $offset, $length);
Nader toelichting:
Gebruik van deze functies verwijdert alle verwijzingen naar deze elementen uit PHP. Als u een sleutel in de array wilt behouden, maar met een lege waarde, wijst u de lege string toe aan het element:
$array[3] = $array['foo'] = '';
Naast de syntaxis is er een logisch verschil tussen het gebruik van unset()en het toewijzen van ” naar het element. De eerste zegt This doesn't exist anymore,terwijl de tweede zegt This still exists, but its value is the empty string.
Als je met getallen te maken hebt, is het misschien een beter alternatief om 0 toe te wijzen. Dus als een bedrijf de productie van het model XL1000-tandwiel zou stopzetten, zou het zijn inventaris bijwerken met:
unset($products['XL1000']);
Als het echter tijdelijk geen XL1000-tandwielen meer had, maar van plan was later deze week een nieuwe zending van de fabriek te ontvangen, is dit beter:
$products['XL1000'] = 0;
Als je unset()een element uitschakelt, past PHP de array aan zodat looping werkt nog steeds correct. Het comprimeert de array niet om de ontbrekende gaten op te vullen. Dit is wat we bedoelen als we zeggen dat alle arrays associatief zijn, zelfs als ze numeriek lijken. Hier is een voorbeeld:
// 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
Om de array te comprimeren tot een dicht gevulde numerieke array, gebruik je array_values():
$animals = array_values($animals);
Als alternatief array_splice()herindexeert automatisch arrays om gaten te voorkomen :
// 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
)
Dit is handig als u de array als wachtrij gebruikt en items uit de wachtrij wilt verwijderen terwijl u toch willekeurige toegang wilt toestaan. Om het eerste of laatste element veilig uit een array te verwijderen, gebruikt u array_shift()en array_pop(), respectievelijk.
Antwoord 18
Gebruik array_search om de sleutel te krijgen en verwijder deze met unset indien gevonden:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
Antwoord 19
Ik zou alleen willen zeggen dat ik een bepaald object had met variabele attributen (het was eigenlijk het in kaart brengen van een tabel en ik veranderde de kolommen in de tabel, dus de attributen in het object, die de tabel weerspiegelen, zouden ook variëren ):
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 {}
}
}
}
Het hele doel van $fieldswas gewoon, dus ik hoef niet overal in de code te kijken wanneer ze worden gewijzigd, ik kijk gewoon naar het begin van de les en verander de lijst van attributen en de $fieldsarray-inhoud om de nieuwe attributen weer te geven.
Antwoord 20
Volg de standaardfuncties:
- PHP: uitgeschakeld
unset()vernietigt de gespecificeerde variabelen. Voor meer informatie kunt u verwijzen naar PHP uitgeschakeld
$Array = array("test1", "test2", "test3", "test3");
unset($Array[2]);
- PHP: array_pop
De functie array_pop()verwijdert het laatste element van een array. Voor meer informatie kunt u verwijzen naar PHP array_pop
$Array = array("test1", "test2", "test3", "test3");
array_pop($Array);
- php: array_splice
De array_splice()Functie verwijdert geselecteerde elementen uit een array en vervangt het met nieuwe elementen. Voor meer informatie kunt u verzenden naar PHP Array_Splice
$Array = array("test1", "test2", "test3", "test3");
array_splice($Array,1,2);
- php: array_shift
De array_shift()functie verwijdert het eerste element van een array. Voor meer informatie kunt u verzenden naar PHP array_shift
$Array = array("test1", "test2", "test3", "test3");
array_shift($Array);
21
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
Maak je array aan in de variabele $arrayen waar ik ‘element you want to delete’ heb gezet, plaats je zoiets als: “a”. En als u meerdere items wilt verwijderen, dan: “a”, “b”.
Antwoord 22
Twee manieren om het eerste item van een array te verwijderen met behoud van de volgorde van de index en ook als u de sleutelnaam van het eerste item niet weet.
Oplossing #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);
Oplossing #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]);
Voor deze voorbeeldgegevens:
$array = array(10 => "a", 20 => "b", 30 => "c");
U moet dit resultaat hebben:
array(2) {
[20]=>
string(1) "b"
[30]=>
string(1) "c"
}
Antwoord 23
unset() meerdere, gefragmenteerde elementen uit een array
Hoewel unset()hier meerdere keren is genoemd, moet nog worden vermeld dat unset()meerdere variabelen accepteert, waardoor het gemakkelijk is om meerdere, niet-aaneengesloten elementen te verwijderen uit een array in één bewerking:
// 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 () Accepteert geen reeks toetsen om te verwijderen, zodat de onderstaande code zal mislukken (het zou het iets gemakkelijker maken om niet-ingrijpende () dynamisch te gebruiken).
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
In plaats daarvan kan unset () dynamisch worden gebruikt in een foreach-lus:
$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]
Array-toetsen verwijderen door de array
te kopiëren
Er is ook een andere praktijk die nog moet worden vermeld.
Soms is de eenvoudigste manier om van bepaalde array-toetsen af te komen om eenvoudig $ array1 te kopiëren in $ array2.
$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 ];
Uiteraard is dezelfde praktijk van toepassing op tekststrings:
$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' ]
24
Een array-element verwijderen op basis van een toets:
Gebruik de unsetfunctie zoals hieronder:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
Verwijder een arrayelement op basis van waarde:
Gebruik de array_searchfunctie om een elementsleutel te krijgen en de bovenstaande manier te gebruiken om een arrayelement zoals hieronder te verwijderen:
$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
)
*/
25
Gebruik de volgende code:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
26
<?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);
?>
Uitvoer
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 )
Antwoord 27
Voor associatieve arrays, met niet-gehele sleutels:
Simpelweg, unset($array[$key])zou werken.
Voor arrays met integer-sleutels en als u uw sleutels wilt behouden:
-
$array = [ 'mango', 'red', 'orange', 'grapes'];unset($array[2]); $array = array_values($array); -
array_splice($array, 2, 1);
Antwoord 28
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
);
print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);
print_r($arrayName);
Antwoord 29
Als u een specifiek object van een array wilt verwijderen door verwijzing naar dat object, kunt u het volgende doen:
unset($array[array_search($object,$array)]);
Voorbeeld:
<?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>';
?>
Resultaat:
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"
}
}
Houd er rekening mee dat als het object meerdere keren voorkomt, het alleen de eerste keer wordt verwijderd!