获取数组的第一个元素-Java 学习之路

899

我有一个数组：

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

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

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

我怎样才能做到这一点？

30 回答

一种愚蠢的方式是：

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

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

print get_first($foo);

回复于 2024-04-29T15:23:40+08:00

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

希望这可以帮助 . :)

回复于 2024-04-29T15:23:40+08:00

4

current($array)

根据PHP Manual可以得到数组的第一个元素

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

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

回复于 2024-04-29T15:23:40+08:00
62

我会做 echo current($array) .

回复于 2024-04-29T15:23:40+08:00
10

我认为使用array_values将是你最好的选择 . 您可以从该函数的结果返回索引零处的值以获取'apple' .

回复于 2024-04-29T15:23:40+08:00
12
假设：
```
$array = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
```
只需使用：
```
$array[key($array)]
```
得到第一个元素或
```
key($array)
```
得到第一把钥匙 .

或者，如果要删除它，可以取消第一个链接 .
回复于 2024-04-29T15:23:40+08:00
1
我喜欢“列表”示例，但“列表”仅适用于作业的左侧 . 如果我们不想分配变量，我们将被迫构成一个临时名称，这最多会污染我们的范围，最坏的情况是覆盖现有值：
```
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()));
```
如果我们使用这样的匿名函数，我们实际上可以使用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())));
```
回复于 2024-04-29T15:23:40+08:00
1150
我没有't like fiddling with the array'的内部指针，但使用 array_keys() 或 array_values() 构建第二个数组效率也很低，所以我通常会定义：
```
function array_first(array $f) {
    foreach ($f as $v) {
        return $v;
    }
    throw new Exception('array was empty');
}
```
回复于 2024-04-29T15:23:40+08:00
9
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) ];
```
回复于 2024-04-29T15:23:40+08:00

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

回复于 2024-04-29T15:23:40+08:00

735

Sarfraz发布的一个小改动是：

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

回复于 2024-04-29T15:23:40+08:00

21
来自Laravel的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;
}
```
回复于 2024-04-29T15:23:40+08:00

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

输出：

apple

回复于 2024-04-29T15:23:40+08:00

两种解决方案 .

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

回复于 2024-04-29T15:23:40+08:00

另外值得注意的是你正在做的事情，因为详尽的检查可能是昂贵的，并不总是必要的 .

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

/**
 * A quick and dirty way to determine whether the passed in array is associative or not, assuming that either:

 * 

 * 1) All the keys are strings - i.e. associative

 * or

 * 2) All the keys are numeric - i.e. not associative

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

回复于 2024-04-29T15:23:40+08:00

4
原始答案，但代价高昂（O（n））：
```
array_shift(array_values($array));
```
在O（1）中：
```
array_pop(array_reverse($array));
```
Edited with suggestions from comments for other use cases etc...

如果修改（在重置数组指针的意义上） $array 不是问题，您可以使用：
```
reset($array);
```
如果需要数组“copy”，理论上这应该更有效：
```
array_shift(array_slice($array, 0, 1));
```
使用PHP 5.4（但如果为空可能会导致索引错误）：
```
array_values($array)[0];
```
回复于 2024-04-29T15:23:40+08:00
86
```
$array=array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

$firstValue = each($array)[1];
```
这比 array_values() 更有效，因为 each() 函数不会复制整个数组 .

有关详细信息，请参阅http://www.php.net/manual/en/function.each.php
回复于 2024-04-29T15:23:40+08:00
6
使用：
```
$first = array_slice($array, 0, 1);  
$val= $first[0];
```
默认情况下， array_slice 不保留键，因此我们可以安全地使用零作为索引 .
回复于 2024-04-29T15:23:40+08:00
1
某些数组不适用于 list ， reset 或 current 等函数 . 也许它们是"faux"数组 - 例如，部分实现ArrayIterator .

如果你想拉第一个值无论数组如何，都可以使迭代器短路：
```
foreach($array_with_unknown_keys as $value) break;
```
然后，您的值将在 $value 中可用，并且循环将在第一次迭代后中断 . 这比将一个可能很大的数组复制到像array_unshift（array_values（$ arr））这样的函数更有效 .

你也可以这样 grab 钥匙：
```
foreach($array_with_unknown_keys as $key=>$value) break;
```
如果您从函数中调用它，只需提前返回：
```
function grab_first($arr) {
    foreach($arr as $value) return $value;
}
```
回复于 2024-04-29T15:23:40+08:00
2
获得第一个元素：
```
array_values($arr)[0]
```
获取最后一个元素
```
array_reverse($arr)[0]
```
回复于 2024-04-29T15:23:40+08:00
1
正如迈克指出的那样（最简单的方法）：
```
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' )
echo reset($arr); //echoes "apple"
```
如果你想获得密钥:(重置后执行）
```
echo key($arr); //echoes "4"
```
来自PHP's documentation：

mixed reset（array＆$ array）;

描述：

reset（）将数组的内部指针倒回第一个元素并返回第一个数组元素的值，如果数组为空则返回FALSE .
回复于 2024-04-29T15:23:40+08:00
10
这个游戏有点晚了，但是我遇到了一个问题，我的数组包含数组元素作为其中的子元素，因此我不能只获得第一个数组元素的字符串表示 . 到using PHP's current() function，我管理了这个：
```
<?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...
?>
```
感谢所有当前的解决方案帮助我得到这个答案，我希望这有时帮助某人！
回复于 2024-04-29T15:23:40+08:00
59
PHP 5.4：
```
array_values($array)[0];
```
回复于 2024-04-29T15:23:40+08:00
9
老帖子但是无论如何...我想作者只是在寻找一种方法来获取数组的第一个元素之后从某个函数（例如mysql_fetch_row）获取它而不生成STRICT“只有变量应该通过引用传递” . 如果是这样的话，almos在这里描述的所有方法都会得到这个消息......并且其中一些使用了大量额外的内存来复制数组（或者它的某些部分） . 避免它的一种简单方法是在调用任何这些函数之前分配值inline：
```
$first_item_of_array = current($tmp_arr = mysql_fetch_row(...));
// or
$first_item_of_array = reset($tmp_arr = func_get_my_huge_array());
```
这样您就不会创建任何其他数组 . 它适用于 both indexed AND associative 数组
回复于 2024-04-29T15:23:40+08:00

252

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

$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

回复于 2024-04-29T15:23:40+08:00

13
简单地说：
```
array_shift(array_slice($array,0,1));
```
回复于 2024-04-29T15:23:40+08:00
7
Most of these work! BUT for a quick single line (low resource) call:
```
$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
回复于 2024-04-29T15:23:40+08:00
4
```
$arr = array( 9 => 'apple', 7 => 'orange', 13 => 'plum' );
echo reset($arr); // echoes 'apple'
```
如果您不想丢失当前指针位置，只需为该数组创建一个别名 .
回复于 2024-04-29T15:23:40+08:00

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

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

回复于 2024-04-29T15:23:40+08:00

1

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

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

回复于 2024-04-29T15:23:40+08:00

获取数组的第一个元素

30 回答

示例（所有这些都需要PHP 7.3）

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

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

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

相关问题