提问



我有一个数组:


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


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


一个要求:通过引用无法完成，因此array_shift不是一个好的解决方案。


我怎样才能做到这一点?

最佳参考


原始答案，但代价高昂(O(n)):


array_shift(array_values($array));


在O(1)中:


array_pop(array_reverse($array));


使用其他用例等的评论建议进行编辑...


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


reset($array);


如果需要数组copy，理论上这应该更有效:


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


使用PHP 5.4+(但如果为空则可能导致索引错误):


array_values($array)[0];

其它参考1


正如迈克指出的那样(最简单的方法):


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


如果你想获得密钥:(重置后执行)


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


来自PHP的文档:[72]



  混合 重置(数组& $ array );



描述:



   reset()将数组的内部指针倒回到第一个元素并返回第一个数组元素的值，如果数组是，则返回FALSE
  空。


其它参考2


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


希望这可以帮助。 :)

其它参考3


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


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

其它参考4


您可以使用语言构造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);

其它参考5


current($array)


根据PHP手册[73]，可以得到数组的第一个元素



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



所以它一直有效，直到你重新定位数组指针，否则你将不得不重置数组。

其它参考6


PHP 5.4+:


array_values($array)[0];

其它参考7


假设:


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


只需使用:


$array[key($array)]


得到第一个元素或


key($array)


得到第一把钥匙。


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

其它参考8


有些数组不能使用像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;
}

其它参考9


简单地说:


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

其它参考10


我愿意echo current($array)。

其它参考11


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


输出:


apple

其它参考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 [74]

其它参考13


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

// the first element of your array is:
echo $myArray[$arrayKeys[0]];

其它参考14


来自Laravel的助手:[75]


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


数组通过值传递给函数，reset()会影响数组副本的内部指针，它不会触及原始数组。(如果数组为空，请注意它返回false [[[76]


用法示例:


$data = ['foo', 'bar', 'baz'];

current($data); // foo
next($data); // bar
head($data); // foo
next($data); // baz



另外，这是另一种选择。它的非常轻微更快，但更有趣的是，如果数组为空，它可以轻松更改默认值:


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

    return $default;
}

其它参考15


大多数工作!但是快速单线(低资源)呼叫:


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

其它参考16


保持这简单!这里有很多正确的答案，但要尽量减少所有的困惑。这两项工作减少了很多开销。


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

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

其它参考17


一种愚蠢的方式是:


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

function get_first ($foo) {
    foreach ($foo as $k=>$v){
        return $v;
    }
}

print get_first($foo);

其它参考18


获得第一个元素:


array_values($arr)[0]


获取最后一个元素


array_reverse($arr)[0]

其它参考19


我认为使用array_values是你最好的选择。您可以从该函数的结果返回索引为零的值，以获得apple。[77]

其它参考20


这个游戏有点晚了，但我遇到了一个问题，我的数组包含数组元素作为其中的子元素，因此我不能只获得第一个数组元素的字符串表示。通过使用PHPs [[current()功能，我管理了这个:[78]


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


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

其它参考21


Sarfraz发布的一个小改动是:


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

其它参考22


使用:


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


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

其它参考23


这在现实世界中不是那么简单的回应。我们有一些可以在一些库中找到的可能响应的例子。


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


您可以看到，我们有几个一线解决方案在某些情况下运行良好，但并非总体而言。


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


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


$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

其它参考24


两种解决方案。


解决方案1 ​​ - 只需使用密钥即可。你还没说，你不能用它。 :)


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


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


解决方案3 - array_keys()


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

其它参考25


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


例如，这种解决方案适用于我使用它的情况(但显然在所有情况下都不能依赖......)


 /**
 * 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));
}

其它参考26


我喜欢列表示例，但列表仅适用于作业的左侧。如果我们不想分配变量，我们将被迫组成一个临时名称，这最多会污染我们的范围，最坏的情况是覆盖现有值:


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


上面将覆盖$ x的任何现有值，只要此范围处于Activity状态(此函数/方法结束，或者如果我们处于顶层)，$ x变量将挂起。这可以使用call_user_func和匿名函数解决这个问题，但它很笨重:


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


如果我们使用这样的匿名函数，我们实际上可以使用reset和array_shift，即使它们使用pass-by-reference。这是因为调用函数将绑定其参数，并且这些参数可以通过引用传递:


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


但是，这实际上是矫枉过正，因为call_user_func将在内部执行此临时赋值。这使我们可以将pass-by-reference函数视为值传递，而不会出现任何警告或错误:


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

其它参考27


老帖子但是无论如何...我想作者只是在寻找一种方法来获取数组的第一个元素之后从某个函数(例如mysql_fetch_row)获取它而不生成STRICT只有变量应该通过引用传递。如果是这样的话，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消息，也不会创建任何其他数组。它适用于索引和关联数组

其它参考28


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


当解决方案是arr[0] 时:



  (注意，由于具有键的数组是基于0的索引，因此第1个
  元素是索引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


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

其它参考29


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


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