获取数组的第一个元素

Question

我有一个数组：

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

我想得到这个数组的第一个元素。预期结果：字符串 apple

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

我该怎么做？

Answer 1

current($array)

返回数组的第一个元素according to the PHP manual。

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

所以它在你重新定位数组指针之前一直有效，否则你将不得不使用reset() 它将倒回数组并返回数组的第一个元素

According to the PHP manual reset.

reset() 将数组的内部指针倒回到第一个元素并返回第一个数组元素的值。

current() 和 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"

Answer 2

<?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: Apple
    echo reset($arr); // Outputs: Apple
    echo next($arr); // Outputs: Ball
    echo current($arr); // Outputs: Ball
    echo reset($arr); // Outputs: Apple
?>

Answer 3

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

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

Answer 4

一行关闭、复制、重置：

<?php

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

echo (function() use ($fruits) { return reset($fruits); })();

输出：

apple

或者更短的短箭头函数：

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

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

Answer 5

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

• array_key_first
• array_key_last

“有几种方法可以为 PHP 7.3.0 之前的版本提供此功能。可以使用 array_keys()，但效率可能相当低。也可以使用 reset() 和 key() ，但是这样可能会改变内部数组指针。一个高效的解决方案，不改变内部数组指针，写成polyfill："

<?php
if (!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));
    }
}
?>

Answer 6

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

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

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

Answer 7

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

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

Answer 8

来自Laravel's helpers：

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;
}

---

为了记录，这里是another answer of mine，表示数组的最后一个元素。

Answer 9

这里的答案太多了，选择的答案适用于大部分情况。

就我而言，我有一个二维数组，array_values 出于某种奇怪的原因正在删除内部数组上的键。所以我最终得到了这个：

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

Answer 10

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

// Get the first item in the array
print $array[0]; // Prints 1

// Get the last item in the array
print end($array);

Answer 11

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

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

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

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

Answer 12

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

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

Answer 13

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

$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快。

Answer 14

还值得牢记的是您执行此操作的环境，因为详尽的检查可能很昂贵且并非总是必要的。

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

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

Answer 15

为您提供两种解决方案。

解决方案 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 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 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]];

Answer 16

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

Answer 17

您可以使用语言结构“列表”获取第 N 个元素：

// First item
list($firstItem) = $yourArray;

// First item from an array that is returned from a function
list($firstItem) = functionThatReturnsArray();

// Second item
list( , $secondItem) = $yourArray;

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

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

Answer 18

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

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

如果要获取密钥：（reset后执行）

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

来自PHP's documentation：

混合 重置（数组&$array）；

说明：

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

Answer 19

原始答案，但代价高昂 (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];

Answer 20

没有人建议使用 ArrayIterator 类：

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

绕过 OP 的引用规定。

Answer 21

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

• array_key_first
• array_key_last

除了语义上的意义之外，这些函数甚至不移动数组指针（就像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) ];

Answer 22

大部分工作！但是对于快速单行（低资源）调用：

$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

Answer 23

试试这个：

$fruits = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($fruits)."\n";

Answer 24

获取第一个元素：

array_values($arr)[0]

获取最后一个元素

array_reverse($arr)[0]

Answer 25

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

输出：

apple

Answer 26

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

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

Answer 27

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

Answer 28

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

当解为arr[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

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

Answer 29

用途：

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

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

Answer 30

简单地做：

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