获取数组的第一个元素

时间：2009-12-17 12:26:44

标签： php arrays

我有一个数组：

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

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

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

我该怎么做？

41 个答案:

答案 0 :(得分：1233)

原始答案，但代价高昂（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 :(得分：748)

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

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

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

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

来自PHP's documentation：

  

混合 重置（数组＆amp; $ array ）;

说明

  

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

答案 2 :(得分：263)

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

希望这会有所帮助。 ：）

答案 3 :(得分：90)

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

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

答案 4 :(得分：75)

current($array)

根据{{​​3}}

，

可以获得数组的第一个元素

  

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

所以它可以工作，直到你重新定位数组指针，否则你将不得不重置数组。

答案 5 :(得分：63)

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

答案 6 :(得分：52)

PHP 5.4 +：

array_values($array)[0];

答案 7 :(得分：27)

假设：

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

只需使用：

$array[key($array)]

获取第一个元素或

key($array)

获得第一把钥匙。

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

答案 8 :(得分：22)

某些数组不适用于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 :(得分：20)

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

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

答案 10 :(得分：16)

来自Laravel的helpers：

AccountNumber   AccountBalance  AccountState    AccountCity
123456          250             TX              Houston

数组通过值传递给函数，reset()影响数组副本的内部指针，它不会触及原始数组。 （注意，如果数组为空，则返回function head($array) { return reset($array); } ）

用法示例：

false

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

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

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


对于记录，这里是another answer of mine，用于数组的最后一个元素。

答案 11 :(得分：13)

简单地说：

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

答案 12 :(得分：11)

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

输出：

apple

答案 13 :(得分：11)

我会做echo current($array)。

答案 14 :(得分：10)

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

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

答案 15 :(得分：9)

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

$firstValue = each($array)[1];

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

有关详细信息，请参阅http://www.php.net/manual/en/function.each.php

答案 16 :(得分：8)

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

“有几种方法可以为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));
    }
}
?>

答案 17 :(得分：8)

一种愚蠢的方式是：

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

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

print get_first($foo);

答案 18 :(得分：7)

获取第一个元素：

array_values($arr)[0]

获取最后一个元素

array_reverse($arr)[0]

答案 19 :(得分：7)

大多数工作！但是快速单线（资源不足）电话： 

$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

答案 20 :(得分：5)

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

current($array) =获取数组的第一个键
$('#search').keyup(function() { var search = $(this).val().toLowerCase(), // add validation that search isn't empty, return if it is // create results array results = string.filter(function(s){ return s.toLowerCase().indexOf(search)>-1; }) // do something with results }) =获取数组的第一个值

答案 21 :(得分：4)

这个游戏有点晚了，但是我遇到了一个问题，我的数组中包含数组元素作为子元素，因此我不能只得到第一个数组元素的字符串表示。到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...
?>

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

答案 22 :(得分：4)

两种解决方案。

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

答案 23 :(得分：4)

使用：

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

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

答案 24 :(得分：4)

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

答案 25 :(得分：2)

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

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

就像你看到的那样，我们有几条“一条线”＆＃39;在某些情况下运行良好的解决方案，但不是全部。

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

现在谈论性能，假设我们总是数组，如下：

$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

答案 26 :(得分：1)

没有人建议使用ArrayIterator类：

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

绕过OP的参考规定。

答案 27 :(得分：1)

一行关闭，复制，重置：

<?php

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

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

输出：

apple

或者较短的短箭头功能：

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

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

答案 28 :(得分：1)

试试这个：

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

答案 29 :(得分：1)

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

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

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

答案 30 :(得分：1)

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

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

答案 31 :(得分：1)

旧帖但无论如何......我想作者只是在寻找一种方法来获取数组的第一个元素之后从某个函数获取它（例如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消息，也不会创建任何其他数组。它适用于索引和关联数组

答案 32 :(得分：1)

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

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将在内部执行此临时分配。这使我们可以将传递引用函数视为按值传递，而不会出现任何警告或错误：

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

答案 33 :(得分：1)

Sarfraz发布的一个小改动是：

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

答案 34 :(得分：0)

组合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

答案 35 :(得分：0)

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

EmpId

或使用

$array_key_set = array_keys($array);
$first_element = $array[$array_key_set[0]];

答案 36 :(得分：0)

使用 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

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

答案 37 :(得分：0)

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

答案 38 :(得分：-1)

使用 reset() 函数：

reset() 函数用于将数组的内部指针移动到第一个元素。

echo reset($array);

使用 array_slice() 函数：

array_slice() 返回数组中由偏移量和长度参数指定的元素序列。

echo array_slice($array, 0, 1)[0];

使用 array_values() 函数：

此函数返回数组的所有值。

echo array_values($array)[0];

使用 array_pop() 函数：

该函数从数组末尾弹出元素。

echo array_pop(array_reverse($array));

使用 array_shift() 函数：

array_shift() 函数从数组中移除第一个元素，并返回移除元素的值。

echo array_shift($array);

输出：

apple

答案 39 :(得分：-3)

此处的答案太多，所选答案适用于大多数情况。在我的情况下，我有一个2D数组，并且由于一些奇怪的原因，array_values删除了内部数组上的键。所以我最终得到了这个

Process.Start(new ProcessStartInfo(tempFile));

答案 40 :(得分：-6)

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

 // get the first item in the array
print $array[0]; // prints 1

// get the last item in the array
print end($array);
相关问题
最新问题