php 在不删除数组的情况下获取数组的最后一个元素的最佳方法是什么？

Question

提问by Theodore R. Smith

Ok,

好的，

I know all about array_pop(), but that deletes the last element. What's the best way to get the last element of an array without deleting it?

我知道所有关于array_pop()，但这会删除最后一个元素。在不删除数组的情况下获取数组的最后一个元素的最佳方法是什么？

EDIT: Here's a bonus:

编辑：这是一个奖励：

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');

or even

甚至

$array = array('a', 'b', 'c', 'd');
unset($array[2]);
echo $array[sizeof($array) - 1]; // Output: PHP Notice:  Undefined offset:  2 in - on line 4

Answer 1

采纳答案by Paul van Leeuwen

The many answers in this thread present us with many different options. To be able to choose from them I needed to understand their behavior and performance. In this answer I will share my findings with you, benchmarked against PHP versions 5.6.38, 7.2.10and 7.3.0RC1(expected Dec 13 2018).

该线程中的许多答案为我们提供了许多不同的选择。为了能够从中选择，我需要了解他们的行为和表现。在这个答案中，我将与您分享我的发现，以 PHP 版本为基准5.6.38，7.2.10以及7.3.0RC1（预计 2018 年 12 月 13 日）。

The options (<<option code>>s) I will test are:

<<option code>>我将测试的选项 ( s) 是：

option .1.$x = array_values(array_slice($array, -1))[0];(as suggestedby rolacja)
option .2.$x = array_slice($array, -1)[0];(as suggestedby Stoutie)
option .3.$x = array_pop((array_slice($array, -1)));(as suggestedby rolacja)
option .4.$x = array_pop((array_slice($array, -1, 1)));(as suggestedby Westy92)
option .5.$x = end($array); reset($array);(as suggestedby Iznogood)
option .6.$x = end((array_values($array)));(as suggestedby TecBrat)
option .7.$x = $array[count($array)-1];(as suggestedby Mirko Pagliai)
option .8.$keys = array_keys($array); $x = $array[$keys[count($keys)-1]];(as suggestedby thrau)
option .9.$x = $array[] = array_pop($array);(as suggestedby user2782001)
option 10.$x = $array[array_key_last($array)];(as suggestedby Quasimodo's clone; available per PHP 7.3)

选项1。$x = array_values(array_slice($array, -1))[0];（如 rolacja 所建议的）
选项 .2。$x = array_slice($array, -1)[0];（所建议的通过Stoutie）
选项 .3。$x = array_pop((array_slice($array, -1)));（如 rolacja 所建议的）
选项 .4。$x = array_pop((array_slice($array, -1, 1)));（所建议的通过Westy92）
选项 .5。$x = end($array); reset($array);（正如伊兹诺古德所建议的那样）
选项 .6。$x = end((array_values($array)));（所建议的通过TecBrat）
选项 .7。$x = $array[count($array)-1];（由Mirko Pagliai 建议）
选项 .8。$keys = array_keys($array); $x = $array[$keys[count($keys)-1]];（所建议的通过thrau）
选项 .9。$x = $array[] = array_pop($array);（由user2782001 建议）
选项10.$x = $array[array_key_last($array)];（如建议由卡西莫多的克隆;每提供PHP 7.3）

(functions mentioned: array_key_last, array_keys, array_pop, array_slice, array_values, count, end, reset)

（提到的函数：array_key_last、array_keys、array_pop、array_slice、array_values、count、end、reset）

The test inputs (<<input code>>s) to combine with:

<<input code>>要结合的测试输入 ( s)：

null= $array = null;
empty= $array = [];
last_null= $array = ["a","b","c",null];
auto_idx= $array = ["a","b","c","d"];
shuffle= $array = []; $array[1] = "a"; $array[2] = "b"; $array[0] = "c";
100= $array = []; for($i=0;$i<100;$i++) { $array[] = $i; }
100000= $array = []; for($i=0;$i<100000;$i++) { $array[] = $i; }

空=$array = null;
空=$array = [];
last_null=$array = ["a","b","c",null];
auto_idx=$array = ["a","b","c","d"];
洗牌=$array = []; $array[1] = "a"; $array[2] = "b"; $array[0] = "c";
100=$array = []; for($i=0;$i<100;$i++) { $array[] = $i; }
100000=$array = []; for($i=0;$i<100000;$i++) { $array[] = $i; }

For testing I will use the 5.6.38, 7.2.10and 7.3.0RC1PHP docker containerslike:

为了测试，我将使用5.6.38,7.2.10和7.3.0RC1PHP docker 容器，例如：

sudo docker run -it --rm php:5.6.38-cli-stretch php -r '<<<CODE HERE>>>'

Each combination of the above listed <<option code>>s and <<input code>>s will be run on all versions of PHP. For each test run the following code snippet is used:

上面列出的<<option code>>s 和<<input code>>s 的每个组合都将在所有版本的 PHP 上运行。对于每次测试运行，使用以下代码片段：

<<input code>>  error_reporting(E_ALL);  <<option code>>  error_reporting(0); $before=microtime(TRUE); for($i=0;$i<100;$i++){echo ".";for($j=0;$j<100;$j++){  <<option code>>  }}; $after=microtime(TRUE); echo "\n"; var_dump($x); echo round(($after-$before)/(100*100)*1000*1000*1000);

For each run this will var_dump the last retrieved last value of the test input and print the average duration of one iteration in femtoseconds(0.000000000000001th of a second).

对于每次运行，这将 var_dump 最后检索到的测试输入的最后一个值，并以飞秒（0.0000000000000001 秒）为单位打印一次迭代的平均持续时间。

The results are as follows:

结果如下：

/==========================================================================================================================================================================================================================================================================================================================================================================================================================\
||                                                                      ||                            T  E  S  T     I  N  P  U  T     -     5  .  6  .  3  8                            ||                             T  E  S  T     I  N  P  U  T     -     7  .  2  .  1  0                           ||                             T  E  S  T     I  N  P  U  T     -     7  .  3  .  0  R  C  1                     ||
||                                                                      ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||          null |         empty |     last_null |      auto_idx |       shuffle |           100 |        100000 ||
||============================OPTIONS - ERRORS==========================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||       W1 + W2 |            N1 |             - |             - |             - |             - |             - ||
||  2.  $x = array_slice($array, -1)[0];                                ||            W1 |            N1 |             - |             - |             - |             - |             - ||            W1 |            N1 |             - |             - |             - |             - |             - ||            W1 |            N1 |             - |             - |             - |             - |             - ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||       W1 + W3 |             - |             - |             - |             - |             - |             - ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||       W1 + W3 |             - |             - |             - |             - |             - |             - ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||  W1 + N2 + W3 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  5.  $x = end($array); reset($array);                                ||       W4 + W5 |             - |             - |             - |             - |             - |             - ||       W4 + W5 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||       W4 + W5 |             - |             - |             - |             - |             - |             - ||
||  6.  $x = end((array_values($array)));                               ||       W2 + W4 |             - |             - |             - |             - |             - |             - ||  W2 + N2 + W4 |             - |             - |             - |             - |             - |             - ||  W2 + N2 + W4 |            N2 |            N2 |            N2 |            N2 |            N2 |            N2 ||
||  7.  $x = $array[count($array)-1];                                   ||             - |            N3 |             - |             - |             - |             - |             - ||            W7 |            N3 |             - |             - |             - |             - |             - ||            W7 |            N3 |             - |             - |             - |             - |             - ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||            W6 |       N3 + N4 |             - |             - |             - |             - |             - ||       W6 + W7 |       N3 + N4 |             - |             - |             - |             - |             - ||       W6 + W7 |       N3 + N4 |             - |             - |             - |             - |             - ||
||  9.  $x = $array[] = array_pop($array);                              ||            W3 |             - |             - |             - |             - |             - |             - ||            W3 |             - |             - |             - |             - |             - |             - ||            W3 |             - |             - |             - |             - |             - |             - ||
|| 10.  $x = $array[array_key_last($array)];                            ||            F1 |            F1 |            F1 |            F1 |            F1 |            F1 |            F1 ||            F2 |            F2 |            F2 |            F2 |            F2 |            F2 |            F2 ||            W8 |            N4 |            F2 |            F2 |            F2 |            F2 |            F2 ||
||========================OPTIONS - VALUE RETRIEVED=====================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  2.  $x = array_slice($array, -1)[0];                                ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  5.  $x = end($array); reset($array);                                ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  6.  $x = end((array_values($array)));                               ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |   bool(false) |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  7.  $x = $array[count($array)-1];                                   ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "b" |       int(99) |    int(99999) ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
||  9.  $x = $array[] = array_pop($array);                              ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||          NULL |          NULL |          NULL | string(1) "d" | string(1) "c" |       int(99) |    int(99999) ||
|| 10.  $x = $array[array_key_last($array)];                            ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||
||=================OPTIONS - FEMTOSECONDS PER ITERATION=================++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============++===============+===============+===============+===============+===============+===============+===============<|
||  1.  $x = array_values(array_slice($array, -1))[0];                  ||           803 |           466 |           390 |           384 |           373 |           764 |     1.046.642 ||           691 |           252 |           101 |           128 |            93 |           170 |        89.028 ||           695 |           235 |            90 |            97 |            95 |           188 |        87.991 ||
||  2.  $x = array_slice($array, -1)[0];                                ||           414 |           349 |           252 |           248 |           246 |           604 |     1.038.074 ||           373 |           249 |            85 |            91 |            90 |           164 |        90.750 ||           367 |           224 |            78 |            85 |            80 |           155 |        86.141 ||
||  3.  $x = array_pop((array_slice($array, -1)));                      ||           724 |           228 |           323 |           318 |           350 |           673 |     1.042.263 ||           988 |           285 |           309 |           317 |           331 |           401 |        88.363 ||           877 |           266 |           298 |           300 |           326 |           403 |        87.279 ||
||  4.  $x = array_pop((array_slice($array, -1, 1)));                   ||           734 |           266 |           358 |           356 |           349 |           699 |     1.050.101 ||           887 |           288 |           316 |           322 |           314 |           408 |        88.402 ||           935 |           268 |           335 |           315 |           313 |           403 |        86.445 ||
||  5.  $x = end($array); reset($array);                                ||           715 |           186 |           185 |           180 |           176 |           185 |           172 ||           674 |            73 |            69 |            70 |            66 |            65 |            70 ||           693 |            65 |            85 |            74 |            68 |            70 |            69 ||
||  6.  $x = end((array_values($array)));                               ||           877 |           205 |           320 |           337 |           304 |         2.901 |     7.921.860 ||           948 |           300 |           336 |           308 |           309 |           509 |    29.696.951 ||           946 |           262 |           301 |           309 |           302 |           499 |    29.234.928 ||
||  7.  $x = $array[count($array)-1];                                   ||           123 |           300 |           137 |           139 |           143 |           140 |           144 ||           312 |           218 |            48 |            53 |            45 |            47 |            51 ||           296 |           217 |            46 |            44 |            53 |            53 |            55 ||
||  8.  $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ||           494 |           593 |           418 |           435 |           399 |         3.873 |    12.199.450 ||           665 |           407 |           103 |           109 |           114 |           431 |    30.053.730 ||           647 |           445 |            91 |            95 |            96 |           419 |    30.718.586 ||
||  9.  $x = $array[] = array_pop($array);                              ||           186 |           178 |           175 |           188 |           180 |           181 |           186 ||            83 |            78 |            75 |            71 |            74 |            69 |            83 ||            71 |            64 |            70 |            64 |            68 |            69 |            81 ||
|| 10.  $x = $array[array_key_last($array)];                            ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           N/A |           N/A |           N/A |           N/A |           N/A |           N/A |           N/A ||           370 |           223 |            49 |            52 |            61 |            57 |            52 ||
 \=========================================================================================================================================================================================================================================================================================================================================================================================================================/

The above mentioned Fatal, Warning and Notice codes translate as:

上述˚F阿塔尔贝哈，w ^arning和Ñotice代码翻译为：

F1 = Fatal error: Call to undefined function array_key_last() in Command line code on line 1
F2 = Fatal error: Uncaught Error: Call to undefined function array_key_last() in Command line code:1
W1 = Warning: array_slice() expects parameter 1 to be array, null given in Command line code on line 1
W2 = Warning: array_values() expects parameter 1 to be array, null given in Command line code on line 1
W3 = Warning: array_pop() expects parameter 1 to be array, null given in Command line code on line 1
W4 = Warning: end() expects parameter 1 to be array, null given in Command line code on line 1
W5 = Warning: reset() expects parameter 1 to be array, null given in Command line code on line 1
W6 = Warning: array_keys() expects parameter 1 to be array, null given in Command line code on line 1
W7 = Warning: count(): Parameter must be an array or an object that implements Countable in Command line code on line 1
W8 = Warning: array_key_last() expects parameter 1 to be array, null given in Command line code on line 1
N1 = Notice: Undefined offset: 0 in Command line code on line 1
N2 = Notice: Only variables should be passed by reference in Command line code on line 1
N3 = Notice: Undefined offset: -1 in Command line code on line 1
N4 = Notice: Undefined index:  in Command line code on line 1

Based on this output I draw the following conclusions:

基于此输出，我得出以下结论：

newer versions of PHP perform better with the exception of these options that became significantly slower:
- option .6.$x = end((array_values($array)));
- option .8.$keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
these options scale best for very large arrays:
- option .5.$x = end($array); reset($array);
- option .7.$x = $array[count($array)-1];
- option .9.$x = $array[] = array_pop($array);
- option 10.$x = $array[array_key_last($array)];(since PHP 7.3)
these options should only be used for auto-indexed arrays:
- option .7.$x = $array[count($array)-1];(due to use of count)
- option .9.$x = $array[] = array_pop($array);(due to assigning value losing original key)
this option does not preserve the array's internal pointer
- option .5.$x = end($array); reset($array);
this option is an attempt to modify option .5.to preserve the array's internal pointer (but sadly it does not scale well for very large arrays)
- option .6.$x = end((array_values($array)));
the new array_key_lastfunction seems to have none of the above mentioned limitations with the exception of still being an RC at the time of this writing (so use the RC or await it's release Dec 2018):
- option 10.$x = $array[array_key_last($array)];(since PHP 7.3)

较新版本的 PHP 性能更好，除了这些选项变得明显变慢：
- 选项 .6。$x = end((array_values($array)));
- 选项 .8。$keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
这些选项最适合非常大的阵列：
- 选项 .5。$x = end($array); reset($array);
- 选项 .7。$x = $array[count($array)-1];
- 选项 .9。$x = $array[] = array_pop($array);
- 选项 10.$x = $array[array_key_last($array)];（自 PHP 7.3 起）
这些选项应该只用于自动索引数组：
- 选项 .7。$x = $array[count($array)-1];（由于使用count）
- 选项 .9。$x = $array[] = array_pop($array);（由于分配值丢失原始密钥）
此选项不保留数组的内部指针
- 选项 .5。$x = end($array); reset($array);
此选项试图修改选项 .5。保留数组的内部指针（但遗憾的是它不能很好地扩展非常大的数组）
- 选项 .6。$x = end((array_values($array)));
array_key_last除了在撰写本文时仍然是 RC 之外，新功能似乎没有上述任何限制（因此请使用 RC 或等待它于 2018 年 12 月发布）：
- 选项 10.$x = $array[array_key_last($array)];（自 PHP 7.3 起）

A bit depending on whether using the array as stack or as queueyou can make variations on option 9.

有点取决于将数组用作堆栈还是队列，您可以对选项 9 进行更改。

Answer 2

回答by Iznogood

Try

尝试

$myLastElement = end($yourArray);

To reset it (thanks @hopeseekr):

重置它（感谢@hopeseekr）：

 reset($yourArray);

Link to manual

链接到手册

@David Murdoch added: $myLastElement = end(array_values($yourArray));// and now you don't need to call reset().On E_STRICT this produces the warning

@David Murdoch 补充说： $myLastElement = end(array_values($yourArray));// and now you don't need to call reset().在 E_STRICT 上，这会产生警告

Strict Standards: Only variables should be passed by reference

Thanks o_O Tync and everyone!

谢谢 o_O Tync 和大家！

Answer 3

回答by rolacja

Short and sweet.

简短而甜蜜。

I came up with solution to remove error message and preserve one-liner form and efficient performance:

我想出了消除错误消息并保留单行形式和高效性能的解决方案：

$lastEl = array_values(array_slice($array, -1))[0];

-- previous solution

-- 以前的解决方案

$lastEl = array_pop((array_slice($array, -1)));

Note: The extra parentheses are needed to avoid a PHP Strict standards: Only variables should be passed by reference.

注意：需要额外的括号来避免PHP Strict standards: Only variables should be passed by reference.

Answer 4

回答by Stoutie

What's wrong with array_slice($array, -1)? (See Manual: http://us1.php.net/array_slice)

怎么了array_slice($array, -1)？（参见手册：http: //us1.php.net/array_slice）

array_slice()returns an array. Probably not what you are looking for. You want the element.

array_slice()返回一个数组。可能不是你要找的。你想要这个元素。

Answer 5

回答by Warbo

One way to avoid pass-by-reference errors (eg. "end(array_values($foo))") is to use call_user_func or call_user_func_array:

避免传递引用错误（例如“end(array_values($foo))”）的一种方法是使用 call_user_func 或 call_user_func_array：

// PHP Fatal error: Only variables can be passed by reference
// No output (500 server error)
var_dump(end(array(1, 2, 3)));

// No errors, but modifies the array's internal pointer
// Outputs "int(3)"
var_dump(call_user_func('end', array(1, 2, 3)));

// PHP Strict standards:  Only variables should be passed by reference
// Outputs "int(3)"
var_dump(end(array_values(array(1, 2, 3))));

// No errors, doesn't change the array
// Outputs "int(3)"
var_dump(call_user_func('end', array_values(array(1, 2, 3))));

Answer 6

回答by Gras Double

If you don't care about modifying the internal pointer (supports both indexed and associative arrays):

如果您不关心修改内部指针（同时支持索引数组和关联数组）：

// false if empty array
$last = end($array);

// null if empty array
$last = !empty($array) ? end($array) : null;

If you want an utility function that doesn't modify the internal pointer (because the array is passed by value, and the function operates on a copy of it):

如果您想要一个不修改内部指针的实用函数（因为数组是按值传递的，并且该函数对它的副本进行操作）：

function array_last($array) {
    if (empty($array)) {
        return null;
    }
    return end($array);
}

Note that PHP produces copies "on-the-fly", i.e. only when actually needed. The end()itself modifies the array, so internally a copy of the array is generated.

请注意，PHP 会“即时”生成副本，即仅在实际需要时生成。的end()本身修改数组，所以在内部产生数组的一个副本。

Thus, the following alternative is actually faster as internally it doesn't copy the array, it just makes a slice:

因此，以下替代方案实际上更快，因为它在内部不复制数组，它只是制作一个切片：

function array_last($array) {
    if (empty($array)) {
        return null;
    }
    foreach (array_slice($array, -1) as $value) {
        return $value;
    }
}

This "foreach / return" is a tweak for efficiently getting the first (and here single) item.

这个“foreach / return”是有效获取第一个（这里是单个）项目的调整。

Finally, the fastest alternative but for indexed arrays only:

最后，最快的替代方法，但仅适用于索引数组：

$last = !empty($array) ? $array[count($array)-1] : null;

For the record, here is another answer of mine, for the array's first element.

作为记录，这是我的另一个答案，用于数组的第一个元素。

Answer 7

回答by TecBrat

untested: wouldn't this work?

未经测试：这行不通？

<?php
$last_element=end(array_values($array));
?>

Since the array returned by array_values is fleeting, no-one cares if it's pointer is reset.

由于 array_values 返回的数组是短暂的，没有人关心它的指针是否被重置。

and if you need the key to go with it I guess you'd do:

如果你需要钥匙来配合它，我想你会这样做：

<?php
$last_key=end(array_keys($array));
?>

Answer 8

回答by thrau

I need this quite often to deal with stacks, and i always find myself baffled that there's no native function that does it without manipulating the array or its internal pointer in some form.

我经常需要这个来处理堆栈，而且我总是发现自己很困惑，没有本地函数可以在不以某种形式操作数组或其内部指针的情况下完成它。

So i usually carry around a util function that's also safe to use on associative arrays.

所以我通常会携带一个 util 函数，它也可以安全地用于关联数组。

function array_last($array) {
    if (count($array) < 1)
        return null;

    $keys = array_keys($array);
    return $array[$keys[sizeof($keys) - 1]];
}

Answer 9

回答by Westy92

To get the last element of an array, use:

要获取数组的最后一个元素，请使用：

$lastElement = array_slice($array, -1)[0];

Benchmark

基准

I iterated 1,000 times, grabbing the last element of small and large arrays that contained 100 and 50,000 elements, respectively.

我迭代了 1,000 次，分别抓取了包含 100 和 50,000 个元素的小型和大型数组的最后一个元素。

Method: $array[count($array)-1];
Small array (s): 0.000319957733154
Large array (s): 0.000526905059814
Note: Fastest!  count() must access an internal length property.
Note: This method only works if the array is naturally-keyed (0, 1, 2, ...).

Method: array_slice($array, -1)[0];
Small array (s): 0.00145292282104
Large array (s): 0.499367952347

Method: array_pop((array_slice($array, -1, 1)));
Small array (s): 0.00162816047668
Large array (s): 0.513121843338

Method: end($array);
Small array (s): 0.0028350353241
Large array (s): 4.81077480316
Note: Slowest...

I used PHP Version 5.5.32.

我使用了 PHP 版本 5.5.32。

Answer 10

回答by Ajith

end() will provide the last element of an array

end() 将提供数组的最后一个元素

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
echo end($array); //output: c

$array1 = array('a', 'b', 'c', 'd');
echo end($array1); //output: d

php 在不删除数组的情况下获取数组的最后一个元素的最佳方法是什么？

提问by Theodore R. Smith

采纳答案by Paul van Leeuwen

回答by Iznogood

回答by rolacja

回答by Stoutie

回答by Warbo

回答by Gras Double

回答by TecBrat

回答by thrau

回答by Westy92

回答by Ajith

相关推荐

最近更新

标签

php 在不删除数组的情况下获取数组的最后一个元素的最佳方法是什么？

提问by Theodore R. Smith

采纳答案by Paul van Leeuwen

回答by Iznogood

回答by rolacja

回答by Stoutie

回答by Warbo

回答by Gras Double

回答by TecBrat

回答by thrau

回答by Westy92

回答by Ajith

相关推荐

php CodeIgniter 中的当前 URI 段

PHP 在其他类中包含类

php 致命错误：允许的内存大小为 134217728 字节已用尽（尝试分配 71 字节）

php 已用完允许的 262144 字节内存大小（尝试分配 24576 字节）

相关推荐

最近更新

标签