获取数组的第一个元素

我有一个数组：

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

我想获得这个数组的第一个元素。 预期结果： string apple

一个要求： 不能通过引用传递 ，所以array_shift不是一个好的解决scheme。

我该怎么做？

Answer 1

原始答案，但昂贵（O（n））：

 array_shift(array_values($array)); 

在O（1）中：

 array_pop(array_reverse($array)); 

其他使用案例的意见build议编辑…

如果修改（重置数组指针） $array不是一个问题，你可以使用：

 reset($array); 

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

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

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

 array_values($array)[0]; 

Answer 2

正如Mike指出的那样（最简单的方法）：

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

如果你想获得钥匙:(复位后执行）

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

从PHP的文档 ：

混合 复位 （array ＆$ array ）;

描述：

reset（）将 数组的内部指针回退到第一个元素，并返回第一个数组元素的值;如果数组为空，则返回FALSE。

Answer 3

 $first_value = reset($array); // First Element's Value $first_key = key($array); // First Element's Key 

希望这可以帮助。 🙂

Answer 4

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

如果您不想丢失当前的指针位置，只需为该数组创build一个别名即可。

Answer 5

你可以用一个语言结构“list”获得第N个元素：

 // 1st item list($firstItem) = $yourArray; // 1st item from an array that is returned from function list($firstItem) = functionThatReturnsArray(); // 2nd item list( , $secondItem) = $yourArray; 

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

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

Answer 6

只需简单地current($array)就可以解决

Answer 7

PHP 5.4+：

 array_values($array)[0]; 

Answer 8

假设：

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

只要使用：

 $array[key($array)] 

得到第一个元素或

 key($array) 

获得第一把钥匙。

或者如果你想删除它，你可以取消第一个链接。

Answer 9

某些数组不能用于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; } 

Answer 10

简单地做：

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

Answer 11

我会做echo current($array) 。

Answer 12

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

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

欲了解更多信息，请参阅http://www.php.net/manual/en/function.each.php

Answer 13

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

输出：

 apple 

Answer 14

大部分工作！ 但是对于快速的单线（低资源）呼叫：

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

Answer 15

一个方便的方法是：

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

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_values是最好的select。 您可以从该函数的结果中返回索引为零的值来获取“apple”。

Answer 18

这是比较晚的游戏，但我被提出了一个问题，其中我的数组包含数组元素作为其内的子元素，因此我不能只是得到第一个数组元素的string表示forms。 通过使用PHP的current()函数 ，我pipe理这个：

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

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

Answer 19

Sarfraz发布的一个小小改变是：

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

Answer 20

获取第一个元素：

 array_values($arr)[0] 

获取最后一个元素

 array_reverse($arr)[0] 

Answer 21

来自Laravel的帮手 ：

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

该数组通过值传递给函数， reset（）影响数组副本的内部指针，它不会触及原始数组。 （注意，如果数组为空，则返回false ）

用法示例：

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

另外，这是一个替代scheme。 它的速度非常快，但是更有趣的是，如果数组为空，它可以轻松地更改默认值：

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

Answer 22

使用：

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

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

Answer 23

两个解决scheme给你。

解决scheme1 ​​ – 只需使用密钥。 你没有说，你不能使用它。 🙂

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

解决scheme2 – 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 an reset in // just to make sure that the array pointer is at first element // also reset return the first element // reset($myArray); // return first key $firstKey = key($array); assert('$firstKey === "apple" /* Expected result: string apple. */'); ?> 

解决scheme3 – array_keys（）

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

Answer 24

这在现实世界中并不是那么简单的回应。 假设我们有一些可能的答案的例子，你可以在一些图书馆find答案。

 $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] ); // Notice var_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; //Notice var_dump($elm); list($elm) = $array2; var_dump($elm); list($elm) = $array3; // Notice var_dump($elm); list($elm) = $array4; var_dump($elm); 

就像你所看到的，我们有几种“一条线”的解决scheme，在某些情况下可以很好地工作，但是不是。

在我看来，你应该只处理数组。

现在谈论性能，假设我们总是这样排列：

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

array_shift是更快的重置，这是更快的[count（） – 1]，这三个更快array_values和array_slice

Answer 25

我喜欢“list”的例子，但是“list”只能在作业的左边进行。 如果我们不想分配一个variables，我们将被迫创build一个临时名称，这最多会污染我们的范围，最坏的情况是覆盖现有的值：

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

以上将覆盖任何现有的$ x值，只要这个范围是活动的（这个函数/方法的结束，或者如果我们处于顶层），$ xvariables就会一直存在。 这可以解决使用call_user_func和匿名函数，但它是笨重的：

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

如果我们使用这样的匿名函数，即使使用传递引用，我们实际上也可以避免使用reset和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()))); 

Answer 26

另外值得注意的是，你在做这件事的背景下，作为一个详尽的检查可能是昂贵的，并不总是必要的。

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

  /** * 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 - ie associative<br/> * or<br/> * 2) All the keys are numeric - ie 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)); } 

Answer 27

使用array_keys()以数字索引数组的forms访问关联数组的键，然后再次可以将其用作数组的键。

当解决scheme是arr[0] ：

（注意，由于具有键的数组是从0开始的索引，所以第一个元素是索引0）

你可以使用一个variables，然后减去一个，得到你的逻辑，即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 

通过第一种方法不只是第一个元素，但可以像索引数组一样处理关联数组。

Answer 28

我不喜欢弄乱数组的内部指针，但是用array_keys()或array_values()构造第二个数组也是低效的，所以我通常定义这个：

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

Answer 29

旧的post，但无论如何…我想作者只是寻找一种方式来获取数组的第一个元素后，从一些函数（例如mysql_fetch_row），而不会产生一个STRICT“只能通过引用传递variables”。 如果是这样的话，almos在这里描述的所有方法都会得到这个消息…而其中一些使用了大量额外的内存复制一个数组（或其中的一部分）。 一个简单的方法来避免它只是在调用任何这些函数之前分配内联值：

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

这样你就不会在屏幕上看到STRICT消息，也不会创build任何额外的数组。 它适用于索引和关联数组

Answer 30

与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