Get the first element of an array

Question

I have an array:

array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )

I would like to get the first element of this array. Expected result: string apple

One requirement: it cannot be done with passing by reference, so array_shift is not a good solution.

How can I do this?

• cjk: What do you mean, can't be done by reference?
• hsz: Function should not works using &$array as params.
• cartbeforehorse: I suspect that what you "really" mean by "can't be done by reference", is that your array is being returned dynamically from a database, and you don't want to pass the array into a variable before taking the first element from it. If I'm right, then the vast majority of all the solutions provided to you below (including the accepted answer), are insufficient.
• Jo Smo: Do you just have to get it or get it and remove it from the existing array?
• Vikrant Vir Bhalla: For basic use of Arrays you can review this link technofusions.com/introduction-to-arrays-in-php

Answer 1

Original answer, but costly (O(n)):

array_shift(array_values($array));

In O(1):

array_pop(array_reverse($array));

Other use cases, etc...

If modifying (in the sense of resetting array pointers) of $array is not a problem, you might use:

reset($array);

This should be theoretically more efficient, if a array "copy" is needed:

array_shift(array_slice($array, 0, 1));

With PHP 5.4+ (but might cause an index error if empty):

array_values($array)[0];

• ChrisR: +1 for the clever workaround to prevent modifying the original array with array_values()
• Simone: I get this: <b>Strict Standards</b>: Only variables should be passed by reference. Nice workaround btw
• Martin Dimitrov: Isn't this a little overkill? What if the array contains several thousands of elements? Is it justified to create a whole new array just to get its first element? list() and reset() are much nicer solutions to my opinion.
• zmonteca: I agree. Total overkill and extraordinary resource heavy compared to one line which resets and returns the current value: reset($array)
• Lightness Races in Orbit: -1 As the above commenters have said. It's baffling to me that this has 101 upvotes.

Answer 2

As Mike pointed out (the easiest possible way):

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // Echoes "apple"

If you want to get the key: (execute it after reset)

echo key($arr); // Echoes "4"

From PHP's documentation:

mixed reset ( array | object &$array );

Description:

reset() rewinds array's internal pointer to the first element and returns the value of the first array element, or FALSE if the array is empty.

• Zenexer: The array's iterator is modified. If you do this in a foreach with the subject array, you'll screw it up.
• Luke Cousins: @Zenexer this is not always (usually) true. Usually in practise, foreach will copy the array which is it looping through.
• lepe: @Angger after reset, you can call key($arr) and you will get '4' (added into answer)
• dmikam: Neither @Zenexer nor Luke Cousins are right: 1) foreach does not use internat pointer of an array - instead it creates it's own pointer. It is easy to check calling reset inside foreach - the loop will follow it's way with no effect from reset(). 2) No, foreach DOES NOT create a copy of an array!!! It only creates it's own pointer (not even a copy of an existing one - it is also easy to check, calling next() before foreach).
• dmikam: @Zenexer Well, you don't have to take my word :) It is pretty well describet in this post: stackoverflow.com/a/14854568/2828391

Answer 3

$first_value = reset($array); // First element's value
$first_key = key($array); // First element's key

• mason81: I haven't actually tested it, but it seems this approach would be the most efficient.
• zmonteca: Only problem is the question asked for the value, not the key. Thus current($array) should be used instead of of key($array)
• S3Mi: @zmonteca $first_value = reset($array); here you get the value, reset() function rewinds arrays internal pointer and returns first element.
• Alain: the best answer! was looking for key() equivalence to get the first value. This helps!
• Jacob: What if the array is empty? reset() will return false, which may lead to bugs if you expect the array to contain bool values.

Answer 4

current($array)

returns the first element of an array, according to the PHP manual.

Every array has an internal pointer to its "current" element, which is initialized to the first element inserted into the array.

So it works until you have re-positioned the array pointer, and otherwise you'll have to use reset() which ll rewind array and ll return first element of array

According to the PHP manual reset.

reset() rewinds array's internal pointer to the first element and returns the value of the first array element.

Examples of current() and 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"

• Jon: current($array) will only work if the array pointer is "currently" pointing to the first element, otherwise reset($array) would be required.
• Ryan: It seems current() no longer requires a reference, although the PHP docs do not reflect this. So I think this has become the best solution.
• CPHPython: @Ryan agreed, but this solution was given 2 years prior to 2014 in this other answer of this same thread... Weird that this incomplete sentence got more upvotes.
• Jacob: What if the array is empty? reset() and current() will return false, which may lead to bugs if you expect the array to contain bool values.
• Jono: Different horses for courses. reset() if you have an array variable. current() when nesting functions e.g. current(array_column([],'key'))

Answer 5

$arr = $array = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'

If you don't want to lose the current pointer position, just create an alias for the array.

• yoda: didn't get it, what do you mean? It works fine whether the key of the first is bigger than the other ones.
• Mike: +1 FYI reset() already returns the first element, so there is no need to use current() -- echo reset($arr) should suffice
• CPHPython: @Mike but you might prefer current to reset to avoid PHP notice/error produced in reference cases, e.g. current(array_filter(...)); in 3v4l.
• Jacob: What if the array is empty? reset() will return false, which may lead to bugs if you expect the array to contain bool values.

Answer 6

PHP 7.3 added two functions for getting the first and the last key of an array directly without modification of the original array and without creating any temporary objects:

• array_key_first
• array_key_last

Apart from being semantically meaningful, these functions don't even move the array pointer (as foreach would do).

Having the keys, one can get the values by the keys directly.

---

Examples (all of them require PHP 7.3+)

Getting the first/last key and value:

$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];

Getting the first/last value as one-liners, assuming the array cannot be empty:

$first_value = $my_array[ array_key_first($my_array) ];
$last_value = $my_array[ array_key_last($my_array) ];

Getting the first/last value as one-liners, with defaults for empty 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) ];

• Mitchell McKenna: Shorten with null-coalescing operator, usually null is default so: $first_value = $my_array[array_key_first($my_array)] ?? null;
• PeterM: They should add array_first too. To get first item. And possibly array_second ;)
• mickmackusa: array_first() is a native function as of PHP8.5

Answer 7

You can get the Nth element with a language construct, "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;

With the array_keys function you can do the same for keys:

list($firstKey) = array_keys($yourArray);
list(, $secondKey) = array_keys($yourArray);

• J. Bruni: This is exactly what I do: list($first_value) = $my_array; In my opinion, the very best option. It does not have the issues from the other answers presented here: no "overkill" because it does not copy or the array or create a new one. No "references": the array is not modified. No "reset": no changes to the array internal pointer...
• Tgr: Very elegant solution, but throws an E_NOTICE when the array is empty.
• Marco Demaio: Isn't this wrong?! It works only if array keys are int, try doing list($firstItem) = array('key1' => 'value1'); and you will get an error Notice: Undefined offset: 0
• Jeff Lambert: @Sergiy but then you loose the biggest advantage of this solution, and that's not copying the entire original array to another needlessly. Still, +1 for the benefits assuming you can guarantee an integer indexed array
• Warbo: To clarify: list($x) = foo(); is equivalent to $x = foo()[0];. Note that this is not necessarily the same as "get the first item", since even an integer-indexed array may not have an element with key 0. In my case I was doing "list($order) = get_order($user);" but "get_order" was returning orders keyed by their ID, which was usually not 0. As @Sergiy says, array_values() fixes this, but detracts from the efficiency and (more importantly) readability of the code.

Answer 8

PHP 5.4+:

array_values($array)[0];

• zdick: PHP 4: $array_values = array_values($array); $value = $array_values[0];
• Bibendus: if the array is empty it will return undefined key 0 so use it with caution

Answer 9

Some arrays don't work with functions like list, reset or current. Maybe they're "faux" arrays - partially implementing ArrayIterator, for example.

If you want to pull the first value regardless of the array, you can short-circuit an iterator:

foreach($array_with_unknown_keys as $value) break;

Your value will then be available in $value and the loop will break after the first iteration. This is more efficient than copying a potentially large array to a function like array_unshift(array_values($arr)).

You can grab the key this way too:

foreach($array_with_unknown_keys as $key=>$value) break;

If you're calling this from a function, simply return early:

function grab_first($arr) {
 foreach($arr as $value) return $value;
}

• Ildar Amankulov: I suppose this is one of the fastest ways because using the language construct foreach rather than a function call (which is more expensive). designcise.com/web/tutorial/…

Answer 10

Suppose:

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

Just use:

$array[key($array)]

to get first element or

key($array)

to get first key.

Or you can unlink the first if you want to remove it.

• Marco Demaio: Wht not simply use current then?

Answer 11

From Laravel's helpers:

function head($array)
{
 return reset($array);
}

The array being passed by value to the function, the reset() affects the internal pointer of a copy of the array, and it doesn't touch the original array (note it returns false if the array is empty).

Usage example:

$data = ['foo', 'bar', 'baz'];
current($data); // foo
next($data); // bar
head($data); // foo
next($data); // baz

Also, here is an alternative. It's very marginally faster, but more interesting. It lets easily change the default value if the array is empty:

function head($array, $default = null)
{
 foreach ($array as $item) {
 return $item;
 }
 return $default;
}

---

For the record, here is another answer of mine, for the array's last element.

Answer 12

Simply do:

array_shift(array_slice($array,0,1));

• mickmackusa: It is an unattractive (and unexplained) technique since there are single-call techniques to achieve the same thing.

Answer 13

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
foreach($arr as $first) break;
echo $first;

Output:

apple

Answer 14

PHP 7.3 added two functions for getting the first and the last key of an array directly without modification of the original array and without creating any temporary objects:

• array_key_first
• array_key_last

There are several ways to provide this functionality for versions prior to PHP 7.3.0. It is possible to use array_keys(), but that may be rather inefficient. It is also possible to use reset() and key(), but that may change the internal array pointer. An efficient solution, which does not change the internal array pointer, written as polyfill:

<?php
if (!function_exists('array_key_first')) {
 function array_key_first($arr) {
 foreach($arr as $key => $unused) {
 return $key;
 }
 return NULL;
 }
}
?>

Source

This polyfill can then be used in this next one:

if (!function_exists('array_key_last')) {
 function array_key_last($arr) {
 return array_key_first(array_reverse($arr, true));
 }
}

• mickmackusa: @DouglasVicentini it is not guaranteed that checking if one function exists will be sufficient to determine if both functions have been declared. It is possible that one of the functions has been declared in userland (independent of the PHP version). If you want a single check based on the PHP version, do that explicitly.

Answer 15

I would do echo current($array) .

• Dan Lugg: @hsz Doesn't matter, current() doesn't error when non-references are passed. Provided that the pointer is still at the beginning this works.
• dmikam: but it produces a Notice which makes your logs dirty and well... you should get rid of Notices also wven if they are not critical
• CPHPython: @dmikam no it does not. Actually reset produces the "Only variables should be passed by reference" notice while current does not: Online PHP Editor example of current(array_filter(...));.
• dmikam: @CPHPython, seems like you are right... looks like I had this idea of current from old times of PHP 4 where it really produces Fatal error: sandbox.onlinephpfunctions.com/code/… The only issue I see in using current is that it does not guarantee that the returned element is the first element of an array (internal pointer may be modified by the called function). Virtually it may return random element of an array.
• dmikam: @CPHPython A bit artificial example, but it demonstrates well my thoughts: sandbox.onlinephpfunctions.com/code/… just imagine that you receive your array from some function that uses next(), end() or any other function that modifies array's internal pointer. In my example, current() returns null because the internal pointer is "out of range" of array. But it may 'virtually' point to any/random element too.

Answer 16

$myArray = array (4 => 'apple', 7 => 'orange', 13 => 'plum');
$arrayKeys = array_keys($myArray);
// The first element of your array is:
echo $myArray[$arrayKeys[0]];

Answer 17

$array=array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
$firstValue = each($array)[1];

This is much more efficient than array_values() because the each() function does not copy the entire array.

For more info see http://www.php.net/manual/en/function.each.php

• user1646111: because the each() function does not copy the entire array. +1
• Carlos Goce: But the thing is that you should do a reset before, if the internal pointer is not at the beginning you are not going to get the first element.
• dmikam: But each() receives an array by reference and the requirement of the initial questions is not to do so

Answer 18

A kludgy way is:

$foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
function get_first ($foo) {
 foreach ($foo as $k=>$v){
 return $v;
 }
}
print get_first($foo);

• random_user_name: At least you're honest - it's kludgy! But, it works, and I've used it in the past until learning the list() technique above.
• Tyzoid: If you are doing this, you might as well use reset() as the array pointer is reset before foreachis called anyway.

Answer 19

Use:

$first = array_slice($array, 0, 1); 
$val= $first[0];

By default, array_slice does not preserve keys, so we can safely use zero as the index.

Answer 20

Most of these work! BUT for a quick single line (low resource) call:

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

Although this works, and decently well, please also see my additional answer: https://stackoverflow.com/a/48410351/1804013

• Tyzoid: This is equivalent to using current($array), which requires that the array's internal pointer be at the first element anyway, in which case, echo reset($array) is most appropriate.
• CPHPython: @Tyzoid he actually wrote another answer here with your suggestion, but he omitted your explanation... Thank you.
• tfont: @Tyzoid: I made an additional answer/update awhile go: stackoverflow.com/a/48410351/1804013

Answer 21

I think using array_values would be your best bet here. You could return the value at index zero from the result of that function to get 'apple'.

Answer 22

This is a little late to the game, but I was presented with a problem where my array contained array elements as children inside it, and thus I couldn't just get a string representation of the first array element. By using PHP's current() function, I managed this:

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

Thanks to all the current solutions helped me get to this answer, I hope this helps someone sometime!

Answer 23

From PHP8.5, array_first() is available as a pointer-ignorant native function to access the first value in an array. Demo

$array = [
 4 => 'apple',
 7 => 'orange',
 13 => 'plum'
];
var_export(
 array_first($array)
);
// 'apple'

This new function was unanimously supported along with array_last().

If the input array is empty, this function returns null (which might also be the value of a non-empty array).

Resources

• https://php.watch/rfcs/array_first_last

• https://php.watch/versions/8.5/array_first-array_last

The polyfill:

function array_first(array $array): mixed { 
 return $array === [] ? null : $array[array_key_first($array)]; 
}

Answer 24

Two solutions for you.

Solution 1 - Just use the key. You have not said that you can not use it. :)

<?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. */');
?>

Solution 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. */');
?>

Solution 3 - array_keys()

echo $array[array_keys($array)[0]];

Answer 25

No one has suggested using the ArrayIterator class:

$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
$first_element = (new ArrayIterator($array))->current();
echo $first_element; //'apple'

gets around the by reference stipulation of the OP.

• Zack Morris: This should be the correct answer. Also works to get the first key: (new ArrayIterator($array))->key(). Note that it correctly returns null for both value and key when the array is empty (rather than returning a pseudo-value like false). Unfortunately doesn't work for Laravel's Collection class though, it always returns null

Answer 26

I imagine the author just was looking for a way to get the first element of an array after getting it from some function (mysql_fetch_row, for example) without generating a STRICT "Only variables should be passed by reference".

If it so, almost all the ways described here will get this message... and some of them uses a lot of additional memory duplicating an array (or some part of it). An easy way to avoid it is just assigning the value inline before calling any of those functions:

$first_item_of_array = current($tmp_arr = mysql_fetch_row(...));
// or
$first_item_of_array = reset($tmp_arr = func_get_my_huge_array());

This way you don't get the STRICT message on screen, nor in logs, and you don't create any additional arrays. It works with both indexed AND associative arrays.

Answer 27

One line closure, copy, reset:

<?php
$fruits = array(4 => 'apple', 7 => 'orange', 13 => 'plum');
echo (function() use ($fruits) { return reset($fruits); })();

Output:

apple

Alternatively the shorter short arrow function:

echo (fn() => reset($fruits))();

This uses by-value variable binding as above. Both will not mutate the original pointer.

• Progrock: Note $copy = $fruits; echo reset($copy); is far more portable accross Php versions.
• Progrock: If you don't care about the original pointer. reset($fruits) will do!

Answer 28

Use array_keys() to access the keys of your associative array as a numerical indexed array, which is then again can be used as key for the array.

When the solution is arr[0]:

(Note, that since the array with the keys is 0-based index, the 1st element is index 0)

You can use a variable and then subtract one, to get your logic, that 1 => 'apple'.

$i = 1;
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[$i-1]];

Output:

apple

Well, for simplicity- just use:

$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[0]];

Output:

apple

By the first method not just the first element, but can treat an associative array like an indexed array.

Answer 29

I like the "list" example, but "list" only works on the left-hand-side of an assignment. If we don't want to assign a variable, we would be forced to make up a temporary name, which at best pollutes our scope and at worst overwrites an existing value:

list($x) = some_array();
var_dump($x);

The above will overwrite any existing value of $x, and the $x variable will hang around as long as this scope is active (the end of this function/method, or forever if we're in the top-level). This can be worked around using call_user_func and an anonymous function, but it's clunky:

var_dump(call_user_func(function($arr) { list($x) = $arr; return $x; },
 some_array()));

If we use anonymous functions like this, we can actually get away with reset and array_shift, even though they use pass-by-reference. This is because calling a function will bind its arguments, and these arguments can be passed by reference:

var_dump(call_user_func(function($arr) { return reset($arr); },
 array_values(some_array())));

However, this is actually overkill, since call_user_func will perform this temporary assignment internally. This lets us treat pass-by-reference functions as if they were pass-by-value, without any warnings or errors:

var_dump(call_user_func('reset', array_values(some_array())));

Answer 30

A small change to what Sarfraz posted is:

$array = array(1, 2, 3, 4, 5);
$output = array_slice($array, 0, 1);
print_r ($output);