关于php：获取数组的第一个元素


Get the first element of an array

我有一个数组：

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

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

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

我该怎么做？

相关讨论

原始答案，但代价高昂(o(n))：

1
array_shift(array_values($array));

在O(1)中：

1
array_pop(array_reverse($array));

用其他用例的评论等建议编辑…

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

1
reset($array);

如果需要数组"副本"，这在理论上应该更有效：

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

使用php 5.4+(但如果为空可能会导致索引错误)：

1
array_values($array)[0];
相关讨论

正如迈克指出的(最简单的方法)：

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

如果您想获取密钥：(重置后执行)

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

从PHP文档中：

mixed reset ( array &$array );

描述：

reset() rewinds array's internal pointer to the first element and returns the value of the first array element, or FALSE if the array is
empty.

相关讨论

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

希望这有帮助。：)

相关讨论

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

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

相关讨论

current($array)

根据php手册，可以得到数组的第一个元素

Every array has an internal pointer to its"current" element, which is initialized to the first element inserted into the array.

所以它一直工作直到你重新定位数组指针，否则你必须重置数组。

相关讨论

您可以使用语言构造"list"获得nth元素：

1
2
3
4
5
6
7
8
// 1st item
list($firstItem) = $yourArray;

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

// 2nd item
list( , $secondItem) = $yourArray;

使用数组键功能，您可以对键执行相同的操作：

1
2
list($firstKey) = array_keys($yourArray);
list(, $secondKey) = array_keys($yourArray);
相关讨论

PHP 5.4 +：

1
array_values($array)[0];
相关讨论

假设：

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

只需使用：

1
$array[key($array)]

获取第一个元素或

1
key($array)

拿到第一把钥匙。

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

相关讨论

有些数组不适用于list、reset或current等函数。可能它们是"人造"数组——例如，部分实现arrayIterator。

如果不管数组如何，都要提取第一个值，则可以将迭代器短路：

1
foreach($array_with_unknown_keys as $value) break;

然后您的值将在$value中可用，循环将在第一次迭代后中断。这比将可能较大的数组复制到类似数组unshift(数组值($arr))的函数更有效。

你也可以这样拿钥匙：

1
foreach($array_with_unknown_keys as $key=>$value) break;

如果您是从函数调用此函数，只需提前返回：

1
2
3
function grab_first($arr) {
    foreach($arr as $value) return $value;
}
相关讨论

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

  • 阿雷耶基耶希
  • 最后一次

除了语义上有意义外，这些函数甚至不会移动数组指针(就像foreach所做的那样)。

有了这些键，就可以直接通过键来获取值。

示例(所有示例都需要php 7.3+)获取第一个/最后一个键和值：

1
2
3
4
5
6
7
$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];

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

1
2
3
$first_value = $my_array[ array_key_first($my_array) ];

$last_value = $my_array[ array_key_last($my_array) ];

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

1
2
3
$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) ];

来自拉拉维尔的助手：

1
2
3
4
function head($array)
{
    return reset($array);
}

数组按值传递给函数时，reset()会影响数组副本的内部指针，它不会接触到原始数组。(注意，如果数组为空，则返回false)

使用实例：

1
2
3
4
5
6
$data = ['foo', 'bar', 'baz'];

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

还有一个选择。它非常快，但更有趣的是，如果数组为空，它可以轻松地更改默认值：

1
2
3
4
5
6
7
8
function head($array, $default = null)
{
    foreach ($array as $item) {
        return $item;
    }

    return $default;
}

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

简单地做：

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

我会做echo current($array)。

相关讨论

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

输出：

1
apple

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

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

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

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

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

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

相关讨论

一个笨拙的方法是：

1
2
3
4
5
6
7
8
9
$foo = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );

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

print get_first($foo);
相关讨论

大部分的工作！但对于快速的单线(低资源)呼叫：

1
2
3
4
$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

相关讨论

获取第一个元素：

1
array_values($arr)[0]

获取最后一个元素

1
array_reverse($arr)[0]
相关讨论

保持简单！这里有很多正确的答案，但要尽量减少混淆。这两项工作可以减少很多开销。

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

相关讨论

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

用途：

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

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

两种解决方案。

解决方案1-只需使用键。你没有说过，你不能用它。：)

1
2
3
4
5
6
7
8
9
10
<?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())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?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-数组键()。

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

这对游戏来说有点晚了，但是我遇到了一个问题，我的数组中包含了数组元素，作为其中的子元素，因此我不能只获得第一个数组元素的字符串表示。通过使用php的current()函数，我管理了：

1
2
3
4
5
<?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...
?>

多亏了目前所有的解决方案帮助我找到了这个答案，我希望这能帮助一些人！

相关讨论

这不是现实世界中简单的反应。最重要的是，我们有一些可能的响应示例，您可以在一些库中找到。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
$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);

如您所见，我们有几个"一线"解决方案在某些情况下工作得很好，但并非全部。

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

现在讨论性能，假设我们总是使用数组，如下所示：

1
2
3
4
5
6
7
8
$elm = empty($array)? null : ...($array);

...you would use without errors:
$array[count($array)-1] ;
array_shift
reset
array_values
array_slice

数组移位比重置更快，比[count()-1]更快，这三个数组移位比数组值和数组切片更快。

没有人建议使用arrayIterator类：

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

绕过操作的引用规定。

旧的帖子，但无论如何…我想作者只是在从某个函数(例如mysql_fetch_row)获取数组的第一个元素后，寻找一种方法，而不生成严格的"只有变量应该通过引用传递"。如果是这样，这里描述的所有方法都会得到这个消息…其中一些使用了大量额外的内存来复制一个数组(或其中的某个部分)。避免这种情况的一个简单方法是，在调用这些函数之前直接将值赋给inline：

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

这样，无论在日志中还是在屏幕上都不会收到严格的消息，也不会创建任何其他数组。它同时适用于索引数组和关联数组

我喜欢"列表"示例，但是"列表"只在任务的左侧起作用。如果我们不想分配一个变量，我们将被迫编一个临时名称，它最多会污染我们的作用域，最坏的情况下会覆盖现有的值：

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

上面的内容将覆盖$X的任何现有值，只要这个作用域是活动的，$X变量就会一直挂起(这个函数/方法的结尾，或者如果我们是顶级的，则永远挂起)。这可以通过使用call_user_func和匿名函数来解决，但这很难做到：

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

如果我们使用类似这样的匿名函数，我们实际上可以通过重置和数组移位来摆脱，即使它们使用的是按引用传递。这是因为调用函数将绑定其参数，并且这些参数可以通过引用传递：

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

但是，这实际上是多余的，因为call-user-func将在内部执行这个临时分配。这使我们可以将传递引用函数视为传递值，而不出现任何警告或错误：

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

Sarfraz发布的一个小变化是：

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

同样值得记住的是，你在做这件事时所处的环境，因为详尽的检查可能是昂贵的，并不总是必要的。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 /**
 * 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));
}
相关讨论

试试这个：

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

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

1
2
3
4
5
6
function array_first(array $f) {
    foreach ($f as $v) {
        return $v;
    }
    throw new Exception('array was empty');
}

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

当溶液为arr[0]时：

(Note, that since the array with the keys is 0-based index, the 1st
element is index 0)

您可以使用一个变量，然后减去一个，得到您的逻辑，即1 => 'apple'。

1
2
3
$i = 1;
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[$i-1]];

输出：

1
apple

嗯，为了简单起见-只需使用：

1
2
$arr = array( 4 => 'apple', 7 => 'orange', 13 => 'plum' );
echo $arr[array_keys($arr)[0]];

输出：

1
apple

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

很好的一个，结合了array_slice和implode：

1
2
3
4
5
6
7
8
9
10
11
12
13
$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

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

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

或使用

1
2
3
4
5
6
7
8
9
10
11
$i=0;
foreach($array as $arr)
{
  if($i==0)
  {
    $first_element=$arr;
    break;
  }
 $i++;
}
echo $first_element;
相关讨论

这里的答案太多，所选的答案对大多数情况都有效。在我的例子中，我有一个二维数组，由于一些奇怪的原因，数组的值是删除内部数组上的键。所以我就这样结束了

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

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

1
2
3
4
5
 // get the first item in the array
print $array[0]; // prints 1

// get the last item in the array
print end($array);
相关讨论