获取数组的第一个元素

我有一个数组：

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

我想获取此数组的第一个元素。预期结果：字符串apple

一个要求：它不能通过引用传递来完成，所以array_shift不是一个好的解决方案。

我怎么能这么做？

1898264 次浏览
小开 
$arr = $array = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );echo reset($arr); // echoes 'apple'

如果您不想丢失当前指针位置，只需为数组创建别名。

小开

一个笨拙的方法是：

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

我认为使用array_values将是您在这里的最佳选择。您可以从该函数的结果返回索引零的值以获得“apple”。

小开
最佳答案

原始答案，但代价高昂（O（n））：

array_shift(array_values($array));

在O（1）中：

array_pop(array_reverse($array));

其他用例等…

如果修改（在重置数组指针的意义上）$array不是问题，您可以使用：

reset($array);

如果需要数组“复制”，理论上这应该更有效：

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

使用PHP 5.4+（但如果为空可能会导致索引错误）：

array_values($array)[0];
小开

Sarfraz发布的一个小变化是：

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

正如迈克所指出的（最简单的方法）：

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

如果你想得到密钥：（重置后执行）

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

从PHP留档：

混合重置（数组|对象$数组）；

问题描述

重置倒带数组的指向第一个元素的内部指针并返回第一个数组元素的值，如果数组为空。

小开

用途：

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

默认情况下，array_slice不保留键，因此我们可以安全地使用零作为索引。

小开

您可以使用语言构造“list”获取第N个元素：

// First itemlist($firstItem) = $yourArray;
// First item from an array that is returned from a functionlist($firstItem) = functionThatReturnsArray();
// Second itemlist( , $secondItem) = $yourArray;

使用array_keys函数，您可以对键执行相同的操作：

list($firstKey) = array_keys($yourArray);list(, $secondKey) = array_keys($yourArray);
小开 
$first_value = reset($array); // First element's value$first_key = key($array); // First element's key
小开 
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );foreach($arr as $first) break;echo $first;

输出：

apple
小开

为您提供两种解决方案。

解决方案1-只需使用密钥。你还没有说你不能使用它。：）

<?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 appleassert('$result === "apple" /* Expected result: string apple. */');?>

解决方案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. */');?>

解决方案3-array_keys（）

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

有些数组不适用于list、reset或current等函数。也许它们是“人造”数组——例如，部分实现了ArrayIterator。

如果你想拉取第一个值而不管数组，你可以短路迭代器：

foreach($array_with_unknown_keys as $value) break;

然后你的值将在$value中可用，循环将在第一次迭代后中断。这比将潜在的大数组复制到像array_unshift（array_values（$arr））这样的函数更有效。

您也可以通过这种方式获取密钥：

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

如果你从一个函数调用它，只需提前返回：

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

假设：

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

只需使用：

$array[key($array)]

得到第一个元素或

key($array)

拿到第一把钥匙。

或者你可以解除关联，如果你想删除它。

小开

我会做echo current($array)。

小开

简单地做：

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

这对游戏来说有点晚了，但是我遇到了一个问题，我的数组包含数组元素作为其子元素，因此我不能只获得第一个数组元素的字符串表示。通过使用PHP的#0函数，我做到了：

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

感谢所有当前的解决方案帮助我得到这个答案，我希望这能帮助某人的某个时候！

小开

PHP 5.4+：

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

这比array_values()高效得多，因为each()函数不会复制整个数组。

更多信息见http://www.php.net/manual/en/function.each.php

小开

我喜欢“list”的例子，但是“list”只适用于赋值的左侧。如果我们不想赋值变量，我们将被迫创建一个临时名称，这充其量会污染我们的范围，最坏的情况下会覆盖现有值：

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

上面的代码将覆盖$x的任何现有值，只要这个作用域处于活动状态，$x变量就会一直存在（这个函数/方法的末尾，或者如果我们处于顶层，则永远存在）。这可以使用call_user_func和匿名函数来解决，但它很笨拙：

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

如果我们像这样使用匿名函数，我们实际上可以逃脱重置和array_shift，即使它们使用引用传递。这是因为调用函数将绑定其参数，这些参数可以通过引用传递： 

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

然而，这实际上是多余的，因为call_user_func将在内部执行这个临时赋值。这让我们可以将引用传递函数视为按值传递，没有任何警告或错误：

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

这些大部分都有效！但是对于快速的单行（低资源）调用：

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

虽然这工作，体面的好，也请参阅我的附加答案：https://stackoverflow.com/a/48410351/1804013

小开

同样值得记住的是，你正在做这件事的背景，因为详尽的检查可能是昂贵的，并不总是必要的。

例如，这个解决方案适用于我正在使用它的情况（但显然不能在所有情况下都依赖它…）

 /*** A quick and dirty way to determine whether the passed in array is associative or not, assuming that either:<br/>* <br/>* 1) All the keys are strings - i.e. associative<br/>* or<br/>* 2) All the keys are numeric - i.e. not associative<br/>** @param array $objects* @return boolean*/private function isAssociativeArray(array $objects){// This isn't true in the general case, but it's a close enough (and quick) approximation for the context in// which we're using it.
reset($objects);return count($objects) > 0 && is_string(key($objects));}
小开

这在现实世界中不是那么简单的响应。假设我们有这些可能的响应示例，您可以在某些库中找到。

$array1 = array();$array2 = array(1,2,3,4);$array3 = array('hello'=>'world', 'foo'=>'bar');$array4 = null;
var_dump('reset1', reset($array1));var_dump('reset2', reset($array2));var_dump('reset3', reset($array3));var_dump('reset4', reset($array4)); // Warning
var_dump('array_shift1', array_shift($array1));var_dump('array_shift2', array_shift($array2));var_dump('array_shift3', array_shift($array3));var_dump('array_shift4', array_shift($array4)); // Warning
var_dump('each1', each($array1));var_dump('each2', each($array2));var_dump('each3', each($array3));var_dump('each4', each($array4)); // Warning
var_dump('array_values1', array_values($array1)[0]); // Noticevar_dump('array_values2', array_values($array2)[0]);var_dump('array_values3', array_values($array3)[0]);var_dump('array_values4', array_values($array4)[0]); // Warning
var_dump('array_slice1', array_slice($array1, 0, 1));var_dump('array_slice2', array_slice($array2, 0, 1));var_dump('array_slice3', array_slice($array3, 0, 1));var_dump('array_slice4', array_slice($array4, 0, 1)); // Warning
list($elm) = $array1; // Noticevar_dump($elm);list($elm) = $array2;var_dump($elm);list($elm) = $array3; // Noticevar_dump($elm);list($elm) = $array4;var_dump($elm);

如您所见，我们有几个“单线”解决方案，在某些情况下运行良好，但并非全部。

在我看来，你应该只使用数组的处理程序。

现在谈论性能，假设我们总是数组，像这样：

$elm = empty($array) ? null : ...($array);
...you would use without errors:$array[count($array)-1];array_shiftresetarray_valuesarray_slice

array_shift比reset快，比[count（）-1]快，这三个比array_values和array_slice快。

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

current($array)

返回数组的第一个元素根据PHP手册。

每个数组都有一个指向其“当前”元素的内部指针，该元素被初始化为插入数组的第一个元素。

所以它可以工作，直到你重新定位数组指针，否则你必须使用reset()来倒带数组并返回数组的第一个元素

根据PHP手动重置

重置数组指向第一个元素的内部指针并返回第一个数组元素的值。

current()和reset()的例子

$array = array('step one', 'step two', 'step three', 'step four');
// by default, the pointer is on the first elementecho current($array) . "<br />\n"; // "step one"
//Forward the array pointer and then reset it
// skip two stepsnext($array);next($array);echo current($array) . "<br />\n"; // "step three"
// reset pointer, start again on step oneecho reset($array) . "<br />\n"; // "step one"
小开

我想作者只是在寻找一种方法，在从某个函数（例如mysql_fetch_row）获取数组的第一个元素后，不生成STRICT“只有变量才应该通过引用传递”。

如果是这样，这里描述的几乎所有方法都会得到这个消息……其中一些使用大量额外的内存来复制数组（或数组的某些部分）。避免它的一个简单方法是在调用任何这些函数之前内联分配值：

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

这样，您就不会在屏幕上或日志中收到STRICT消息，也不会创建任何额外的数组。它适用于索引和联想数组。

小开

使用#0将关联数组的键作为数字索引数组访问，然后再次可用作数组的键。

当解为#0时：

（注意，由于具有键的数组是基于0的索引，因此第一个元素是索引0）

您可以使用一个变量，然后减去一个，以获得您的逻辑，即1 => 'apple'。

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

输出：

apple

好吧，为了简单起见-只需使用：

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

输出：

apple

通过第一种方法不仅可以处理第一个元素，还可以将关联数组视为索引数组。

小开

查找数组中的第一个和最后一个项目：

// Get the first item in the arrayprint $array[0]; // Prints 1
// Get the last item in the arrayprint end($array);
小开

array_slice和implode的组合不错：

$arr = array(1, 2, 3);echo implode(array_slice($arr, 0, 1));// Outputs 1
/*---------------------------------*/
$arr = array('key_1' => 'One','key_2' => 'Two','key_3' => 'Three',);echo implode(array_slice($arr, 0, 1));// Outputs One
小开

我不喜欢摆弄数组的内部指针，但用array_keys()或array_values()构建第二个数组也效率低下，所以我通常定义如下：

function array_first(array $f) {foreach ($f as $v) {return $v;}throw new Exception('array was empty');}
小开

这里有太多的答案，选择的答案将适用于大多数情况。

在我的例子中，我有一个2D数组，出于某种奇怪的原因，array_values删除了内部数组上的键。所以我结束了这个：

$keys = array_keys($myArray); // Fetches all the keys$firstElement = $myArray[$keys[0]]; // Get the first element using first key
小开

从Laravel的助手：

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

数组按值传递给函数，重置影响数组副本的内部指针，并且它不接触原始指针数组（注意，如果数组为空，则返回false）。

使用示例：

$data = ['foo', 'bar', 'baz'];
current($data); // foonext($data); // barhead($data); // foonext($data); // baz

此外，这是一个替代方案。它非常轻微更快，但更有趣。如果数组为空，它可以轻松更改默认值：

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

为了记录，这里是我的另一个答案，用于数组的最后一个元素。

小开

保持简单！这里有很多正确的答案，但为了尽量减少所有的混乱，这两个工作并减少了大量的开销：

key($array)获取数组的第一个键
current($array)获取数组的第一个值


编辑：
关于下面的注释。以下示例将输出：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));
小开

您可以使用此编码获取第一个元素：

$array_key_set = array_keys($array);$first_element = $array[$array_key_set[0]];

或使用：

$i=0;foreach($array as $arr){if($i==0){$first_element=$arr;break;}$i++;}echo $first_element;
小开

php7.3添加了两个函数来获取数组直接的第一个和最后一个键，而无需修改原始数组，也无需创建任何临时对象：

除了语义上有意义之外，这些函数甚至不会移动数组指针（就像foreach所做的那样）。

有了键，可以直接通过键获取值。

示例（所有示例都需要PHP 7.3+）

获取第一个/最后一个键和值：

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

以单行方式获取第一个/最后一个值，假设数组不能为空：

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

获取第一个/最后一个值作为单行，默认为空数组：

$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) ];
小开

没有人建议使用ArrayIterator类：

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

绕过OP的引用规定。

小开

php7.3添加了两个函数来获取数组直接的第一个和最后一个键，而无需修改原始数组，也无需创建任何临时对象：

有几种方法可以为PHP 7.3.0之前的版本提供此功能。可以使用array_keys（），但这可能相当低效。也可以使用重置（）和键（），但这可能会更改内部数组指针。一个有效的解决方案，它不更改内部数组指针，写为poly填充：

<?phpif (!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));}}?>
小开

一行关闭、复制、重置：

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

输出：

apple

或者更短的短箭头函数：

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

这使用如上所述的副值变量绑定。两者都不会改变原始指针。

小开 
<?php$arr = array(3 => "Apple", 5 => "Ball", 11 => "Cat");echo array_values($arr)[0]; // Outputs: Apple?>

其他示例：

<?php$arr = array(3 => "Apple", 5 => "Ball", 11 => "Cat");echo current($arr); // Outputs: Appleecho reset($arr); // Outputs: Appleecho next($arr); // Outputs: Ballecho current($arr); // Outputs: Ballecho reset($arr); // Outputs: Apple?>
小开

如果你使用Laravel，你可以这样做：

$array = ['a', 'b', 'c'];$first = collect($array)->first();

提交答案