同样值得记住的是您执行此操作的上下文，因为详尽的检查可能是昂贵的，而且并不总是必要的。

例如，这个解决方案在我使用它的情况下工作得很好(但显然不能在所有情况下都依赖它……)

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

正如Mike指出的(最简单的方法):

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

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

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

来自PHP的文档:

混合重置(数组|对象和$array);

描述:

reset()返回数组的内部指针指向第一个元素并返回第一个元素的值，如果数组为 空的。

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

$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比reset快，这比[count()-1]快，这三个比array_values和array_slice快。

来自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

这里还有一个选择。它稍微快一点，但更有趣。如果数组为空，它可以很容易地更改默认值:

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

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

同样值得记住的是您执行此操作的上下文，因为详尽的检查可能是昂贵的，而且并不总是必要的。

例如，这个解决方案在我使用它的情况下工作得很好(但显然不能在所有情况下都依赖它……)

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

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

当解为arr[0]时:

(注意，由于具有键的数组是基于0的索引，因此第1 元素是索引0)

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

通过第一种方法，不仅可以处理第一个元素，还可以像对待索引数组一样对待关联数组。