Ik heb een array:
array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )
Ik zou graag het eerste element van deze array willen hebben. Verwacht resultaat: stringapple
Eén vereiste: het kan niet worden gedaan met het doorgeven van referentie, dus array_shiftis geen goede oplossing.
Hoe kan ik dit doen?
Antwoord 1, autoriteit 100%
Oorspronkelijk antwoord, maar duur (O(n)):
array_shift(array_values($array));
In O(1):
array_pop(array_reverse($array));
Andere toepassingen, enz…
Als het wijzigen (in de zin van het opnieuw instellen van array-pointers) van $arraygeen probleem is, kunt u het volgende gebruiken:
reset($array);
Dit zou theoretisch efficiënter moeten zijn als een array-kopie nodig is:
array_shift(array_slice($array, 0, 1));
Met PHP 5.4+ (maar kan een indexfout veroorzaken als deze leeg is):
array_values($array)[0];
Antwoord 2, autoriteit 54%
Zoals Mike aangaf (de gemakkelijkste manier):
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )
echo reset($arr); // Echoes "apple"
Als je de sleutel wilt krijgen: (voer het uit na reset)
echo key($arr); // Echoes "4"
Van PHP-documentatie:
gemengdreset( array &$array);
Beschrijving:
reset()spoelt de interne aanwijzer van arrayterug naar het eerste element en retourneert de waarde van het eerste array-element, of FALSE als de array
leeg.
Antwoord 3, autoriteit 20%
$first_value = reset($array); // First element's value
$first_key = key($array); // First element's key
Antwoord 4, autoriteit 8%
current($array)
retourneert het eerste element van een array, volgens de PHP-handleiding.
Elke array heeft een interne aanwijzer naar het “huidige” element, dat wordt geïnitialiseerd naar het eerste element dat in de array wordt ingevoegd.
Het werkt dus totdat je de array-aanwijzer opnieuw hebt gepositioneerd, en anders moet je reset()gebruiken, waarmee de array wordt teruggespoeld en het eerste element van de array wordt geretourneerd
Volgens de handmatige PHP-reset.
reset() spoelt de interne aanwijzer van de array terug naar het eerste element en retourneert de waarde van het eerste array-element.
Voorbeelden van current()en reset()
$array = array('step one', 'step two', 'step three', 'step four');
// by default, the pointer is on the first element
echo current($array) . "<br />\n"; // "step one"
//Forward the array pointer and then reset it
// skip two steps
next($array);
next($array);
echo current($array) . "<br />\n"; // "step three"
// reset pointer, start again on step one
echo reset($array) . "<br />\n"; // "step one"
Antwoord 5, autoriteit 7%
$arr = $array = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'
Als u de huidige aanwijzerpositie niet wilt verliezen, maakt u gewoon een alias voor de array.
Antwoord 6, autoriteit 5%
Je kunt het N-de element krijgen met een taalconstructie, “list”:
// First item
list($firstItem) = $yourArray;
// First item from an array that is returned from a function
list($firstItem) = functionThatReturnsArray();
// Second item
list( , $secondItem) = $yourArray;
Met de functie array_keyskun je hetzelfde doen voor sleutels:
list($firstKey) = array_keys($yourArray);
list(, $secondKey) = array_keys($yourArray);
Antwoord 7, autoriteit 4%
PHP 5.4+:
array_values($array)[0];
Antwoord 8, autoriteit 3%
PHP 7.3heeft twee functies toegevoegd om de eerste en de laatste sleutel van een array rechtstreeksop te halen zonder wijziging van de originele array en zonder tijdelijke objecten te maken:
Behalve dat ze semantisch betekenisvol zijn, verplaatsen deze functies de array-aanwijzer niet eens (zoals foreachzou doen).
Als je de sleutels hebt, kun je de waarden direct met de sleutels ophalen.
Voorbeelden (allemaal vereist PHP 7.3+)
De eerste/laatste sleutel en waarde ophalen:
$my_array = ['IT', 'rules', 'the', 'world'];
$first_key = array_key_first($my_array);
$first_value = $my_array[$first_key];
$last_key = array_key_last($my_array);
$last_value = $my_array[$last_key];
De eerste/laatste waarde krijgen als oneliners, ervan uitgaande dat de array niet leeg kan zijn:
$first_value = $my_array[ array_key_first($my_array) ];
$last_value = $my_array[ array_key_last($my_array) ];
De eerste/laatste waarde ophalen als oneliners, met standaardwaarden voor lege arrays:
$first_value = empty($my_array) ? 'default' : $my_array[ array_key_first($my_array) ];
$last_value = empty($my_array) ? 'default' : $my_array[ array_key_last($my_array) ];
Antwoord 9, autoriteit 2%
Stel:
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
Gebruik gewoon:
$array[key($array)]
om het eerste element te krijgen of
key($array)
om de eerste sleutel te krijgen.
Of je kunt de eerste ontkoppelen als je deze wilt verwijderen.
Antwoord 10, autoriteit 2%
Sommige arrays werken niet met functies zoals list, resetof current. Misschien zijn het “faux”-arrays – bijvoorbeeld gedeeltelijk ArrayIterator implementerend.
Als u de eerste waarde wilt ophalen, ongeacht de array, kunt u een iterator kortsluiten:
foreach($array_with_unknown_keys as $value) break;
Uw waarde is dan beschikbaar in $valueen de lus wordt verbroken na de eerste iteratie. Dit is efficiënter dan het kopiëren van een potentieel grote array naar een functie als array_unshift(array_values($arr)).
Je kunt de sleutel ook op deze manier pakken:
foreach($array_with_unknown_keys as $key=>$value) break;
Als je dit vanuit een functie aanroept, kom dan gewoon vroeg terug:
function grab_first($arr) {
foreach($arr as $value) return $value;
}
Antwoord 11
Van Laravel’s helpers:
function head($array)
{
return reset($array);
}
De array die op waarde wordt doorgegeven aan de functie, de reset()beïnvloedt de interne aanwijzer van een kopie van de array en raakt het origineel niet aan
array (merk op dat het falseretourneert als de array leeg is).
Gebruiksvoorbeeld:
$data = ['foo', 'bar', 'baz'];
current($data); // foo
next($data); // bar
head($data); // foo
next($data); // baz
ook, hier is een alternatief. Het is zeer marginaal sneller, maar interessanter. Het laat de standaardwaarde eenvoudig wijzigen als de array leeg is:
function head($array, $default = null)
{
foreach ($array as $item) {
return $item;
}
return $default;
}
Voor het record, hier is Een ander antwoord van de mijne , voor het laatste element van de array.
Antwoord 12
Houd dit eenvoudig! Er zijn hier veel correcte antwoorden, maar om alle verwarring, deze twee werk te minimaliseren en veel overhead te verminderen:
key($array)krijgt de eerste sleutel van een array
current($array)krijgt de eerste waarde van een array
Edit:
Met betrekking tot de onderstaande opmerkingen. Het volgende voorbeeld wordt uitgevoerd: string(13) "PHP code test"
$array = array
(
'1' => 'PHP code test',
'foo' => 'bar', 5 , 5 => 89009,
'case' => 'Random Stuff: '.rand(100,999),
'PHP Version' => phpversion(),
0 => 'ending text here'
);
var_dump(current($array));
Antwoord 13
Doe gewoon:
array_shift(array_slice($array,0,1));
Antwoord 14
Ik zou doen echo current($array).
Antwoord 15
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
foreach($arr as $first) break;
echo $first;
Uitvoer:
apple
Antwoord 16
$myArray = array (4 => 'apple', 7 => 'orange', 13 => 'plum');
$arrayKeys = array_keys($myArray);
// The first element of your array is:
echo $myArray[$arrayKeys[0]];
Antwoord 17
$array=array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
$firstValue = each($array)[1];
Dit is veel efficiënter dan array_values()omdat de functie each()niet de hele array kopieert.
Voor meer info zie http://www.php.net/manual/en/function.each .php
Antwoord 18
Eerste element ophalen:
array_values($arr)[0]
Laatste element ophalen
array_reverse($arr)[0]
Antwoord 19
PHP 7.3heeft twee functies toegevoegd om de eerste en de laatste sleutel van een array rechtstreeksop te halen zonder wijziging van de originele array en zonder tijdelijke objecten te maken:
“Er zijn verschillende manieren om deze functionaliteit te bieden voor versies ouder dan PHP 7.3.0. Het is mogelijk om array_keys() te gebruiken, maar dat kan nogal inefficiënt zijn. Het is ook mogelijk om reset() en key() te gebruiken , maar dat kan de interne array-pointer veranderen. Een efficiënte oplossing, die de interne array-pointer niet verandert, geschreven als polyfill:”
<?php
if (!function_exists('array_key_first')) {
function array_key_first($arr) {
foreach($arr as $key => $unused) {
return $key;
}
return NULL;
}
}
if (!function_exists('array_key_last')) {
function array_key_last($arr) {
return array_key_first(array_reverse($arr, true));
}
}
?>
Antwoord 20
Een onhandige manier is:
$foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
function get_first ($foo) {
foreach ($foo as $k=>$v){
return $v;
}
}
print get_first($foo);
Antwoord 21
De meeste van deze werken! MAAR voor een snelle enkele lijn (lage middelen) oproep:
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $array[key($array)];
// key($array) -> will return the first key (which is 4 in this example)
Hoewel dit werkt, en behoorlijk goed, zie ook mijn aanvullende antwoord:
https://stackoverflow.com/a/48410351/1804013
Antwoord 22
Gebruik:
$first = array_slice($array, 0, 1);
$val= $first[0];
Standaard bewaart array_slicegeen sleutels, dus we kunnen veilig nul als index gebruiken.
Antwoord 23
Dit is een beetje laat voor het spel, maar ik kreeg een probleem voorgeschoteld waarbij mijn array als kinderen array-elementen bevatte, en dus kon ik niet zomaar een string-representatie van het eerste array-element krijgen. Door de current()-functievan PHP te gebruiken, slaagde ik erin dit:
<?php
$original = array(4 => array('one', 'two'), 7 => array('three', 'four'));
reset($original); // to reset the internal array pointer...
$first_element = current($original); // get the current element...
?>
Dankzij alle huidige oplossingen die me hebben geholpen om tot dit antwoord te komen, ik hoop dat dit iemand ooit helpt!
Antwoord 24
Ik denk dat het gebruik van array_valueshier de beste keuze is. Je zou de waarde op index nul uit het resultaat van die functie kunnen retourneren om ‘appel’ te krijgen.
Antwoord 25
Twee oplossingen voor jou.
Oplossing 1 – Gebruik gewoon de sleutel. Je hebt niet gezegd dat je het niet kunt gebruiken. 🙂
<?php
// Get the first element of this array.
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
// Gets the first element by key
$result = $array[4];
// Expected result: string apple
assert('$result === "apple" /* Expected result: string apple. */');
?>
Oplossing 2 – array_flip() + key()
<?php
// Get first element of this array. Expected result: string apple
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
// Turn values to keys
$array = array_flip($array);
// You might thrown a reset in just to make sure
// that the array pointer is at the first element.
// Also, reset returns the first element.
// reset($myArray);
// Return the first key
$firstKey = key($array);
assert('$firstKey === "apple" /* Expected result: string apple. */');
?>
Oplossing 3 – array_keys()
echo $array[array_keys($array)[0]];
Antwoord 26
Niemand heeft voorgesteld om de klasse ArrayIterator te gebruiken:
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
$first_element = (new ArrayIterator($array))->current();
echo $first_element; //'apple'
omzeilt de referentiebepaling van de OP.
Antwoord 27
Ik stel me voor dat de auteur gewoon op zoek was naar een manier om het eerste element van een array te krijgen nadat hij het van een of andere functie had gekregen (mysql_fetch_row, bijvoorbeeld) zonder een STRIKTE “Alleen variabelen moeten worden doorgegeven door verwijzing” te genereren.
Als dat zo is, zullen bijna alle manieren die hier worden beschreven dit bericht krijgen… en sommige gebruiken veel extra geheugen om een array (of een deel ervan) te dupliceren. Een gemakkelijke manier om dit te vermijden, is door de waarde inline toe te wijzen voordat een van deze functies wordt aangeroepen:
$first_item_of_array = current($tmp_arr = mysql_fetch_row(...));
// or
$first_item_of_array = reset($tmp_arr = func_get_my_huge_array());
Op deze manier krijg je niet het strikte bericht op het scherm, noch in logs, en je maakt geen extra arrays. Het werkt met zowel geïndexeerde als associatieve arrays.
Antwoord 28
Gebruik array_keys()om toegang te krijgen tot de sleutels van uw associatieve array als een numerieke geïndexeerde array, die dan opnieuw is gebruikt als sleutel voor de array.
Wanneer de oplossing arr[0]:
(Opmerking, dat sinds de array met de toetsen 0-gebaseerde index is, de 1e
element is index 0)
U kunt een variabele gebruiken en vervolgens één aftrekken, om uw logica te krijgen, die 1 => 'apple'.
$i = 1;
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[$i-1]];
output:
apple
Nou, voor eenvoud – gewoon gebruiken:
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[0]];
output:
apple
door de eerste methode niet alleen het eerste element, maar kan een associatieve array behandelen zoals een geïndexeerde array.
Antwoord 29
Ik hou niet van DIENLEN met de interne aanwijzer van de array, maar het is ook inefficiënt om een tweede array te bouwen met array_keys()of array_values(), dus ik meestal Definieer dit:
function array_first(array $f) {
foreach ($f as $v) {
return $v;
}
throw new Exception('array was empty');
}
Antwoord 30
Probeer dit:
$fruits = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($fruits)."\n";