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

427

好，

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

编辑：这是奖金：

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

甚至

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

php arrays

— 西奥多·史密斯
source

11

信不信由你，弹出它，然后放回去，这是我以此为基准的最快方法之一。$ val = $ array [] = array_pop（$ array）; echo $ val;

— user2782001

2

这个问题导致了许多选择。为了帮助自己进行选择，我对一些最显着/不同的选项进行了比较，并将结果共享为一个单独的答案。（：@ user2782001在上面的评论中建议了我到目前为止最喜欢的。:)感谢所有人的贡献！

— Paul van Leeuwen'2

1

@TheodoreRSmith当PHP 7.3发行时，您可以考虑（由Quasimodo的克隆人提出的建议是“可接受的答案”（供您考虑）...

— Paul van Leeuwen，

175

此主题中的许多答案为我们提供了许多不同的选择。为了能够从他们中进行选择，我需要了解他们的行为和表现。在此答案中，我将与您分享我的发现5.6.38，7.2.10并针对PHP版本和7.3.0RC1（预计于2018年12月13日）进行测试。

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

选项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);（所建议的通过了Iznogood）
选项.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）

（提到的功能：array_key_last，array_keys，array_pop，array_slice，array_values，count，end，reset）

测试输入<<input code>>与以下各项组合：

空 =$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; }

为了测试我将使用5.6.38，7.2.10和7.3.0RC1 PHP搬运工容器，如：

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

上面列出的<<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);

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

结果如下：

/==========================================================================================================================================================================================================================================================================================================================================================================================================================\
||                                                                      ||                            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 ||
 \=========================================================================================================================================================================================================================================================================================================================================================================================================================/

上述˚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

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

较新版本的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起）

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

— 保罗·范·吕文
source

如果您发现缺少某个特定选项，则可以通过将上述代码段复制粘贴在一起，然后将其与先前测试过的选项进行比较，来自己进行测试。要向此列表添加选项，将要重新测试所有组合以获得可比较的性能结果。如果您认为应该添加一个特定的选项，请发表评论，我打算随后添加（尽管可能需要一些时间）。

— Paul van Leeuwen

1

很好的答案，但有一条评论：对于关联数组，也不能使用选项9，因为我们将分配回自动索引键而不是先前的键名。

— Gras Double

1

不错的总结！请使用新的PHP 7.3 添加我的答案。发挥$array[array_key_last($array)];您的基准。完成后请给我一些通知。我想比较一下性能结果。

— Quasimodo的克隆版'18

2

@sz主要是因为产生了很多固执和耐心，但是Sublime文本编辑器的常规选择和多行编辑功能有所帮助。再生花了将近一天的时间，所以如果我需要再次做，我可能会写一些东西，将所有210个Docker执行的输出自动转换为表格：-)

— Paul van Leeuwen

1

@ quasimodos-clone我根据最新发布的PHP 5、7和您的RC重新生成了整个表。我想我们将要在12月实际发布时再次生成它。感谢您将此新功能引起大家的注意。

— Paul van Leeuwen

487

尝试

$myLastElement = end($yourArray);

重置它（感谢@hopeseekr）：

 reset($yourArray);

链接到手册

@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

谢谢o_O Tync和大家！

— 伊兹诺古德
source

38

使用$myLastElement = end(array_values($yourArray));，现在您无需致电reset()。

— David Murdoch'4

5

@DavidMurdoch也许，但是它确实会搅动RAM和CPU，为数组值创建临时数组...

— Theodore R. Smith

12

如果您的服务器消耗过多的RAM，以至于调用一个简单的额外功能很麻烦，那么我建议您重新检查服务器的配置和资源。

— 克里斯·贝克

3

end(array_values())将给出一个E_STRICT：“只能通过引用传递变量”

— kolypto 2012年

32

添加额外的括号以避免严格的警告：end((array_values($yourArray)))

— Daniel W.

212

简短而甜美。

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

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

-以前的解决方案

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

注意：需要使用多余的括号来避免PHP Strict standards: Only variables should be passed by reference。

— 罗拉贾
source

31

经过5年零6个月零2天，您已经提交了更出色的答案！！谢谢！并感谢堆栈溢出！

— 西奥多·R·史密斯，

1

欢迎回答，但加上多余的括号会让人有点头疼。另外phpStorm会将其标记为错误。添加额外括号的额外信息（phpsadness.com/sad/51）。要克服该错误，可以将其设置为“ 2-liner”：就$array = array_slice($array, -1); $lastEl = array_pop($array);我个人而言，我认为这更好（没有解析器“ bug”）

— Maurice

3

您可以像这样使用解引用：array_slice（$ array，-1）[0]

— Vikash

1

如果字符串中有字符串作为数组中的索引，则无法显示

— rolacja

3

这个答案仍然至少需要两项检查才能避免PHP通知。1.检查是否array_size() > 1 2.检查该数组是否实际上是一个数组。 我仍然坚持@Iznogood的答案，因为PHP的内置end()函数已经以更有效的方式完成了所有艰苦的工作。

— Ema4rl

37

这有什么错array_slice($array, -1)？（请参见手册：http : //us1.php.net/array_slice）

array_slice()返回一个数组。可能不是您要找的东西。您需要元素。

— 矮胖
source

21

使用array_slice($array, -1)[0]获得的元素。

— 庞

2

这就是答案。“ end”更改数组的内部指针？自找麻烦，而且很难阅读！

— Gerard ONeill 2015年

喜欢这种方法，尽管正如@Pang指出的那样，它并不完整。 reset(array_slice($array, -1))是另一种方法（如果array_slice()返回比单个元素数组“小”的东西，则不会导致错误）

— rinogo 2016年

您可以直接修改元素的最佳方法：array_slice($array, -1)[0] = "";

— HAlex

20

避免传递引用错误（例如“ 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))));

— 华宝
source

好办法！（在此处插入标准的“这应该是可接受的答案”）

— 错字

3

或者只是添加一个额外的括号。更矮更甜：end((array_values($yourArray)))

— Dzhuneyt 2014年

4

额外的括号技巧依赖于PHP中的错误，并且该方法在更高版本的PHP中（或至少在PHP 7中不再可用）不再有效。

— 马特·布朗

1

而且该call_user_func技巧在PHP 7中也不起作用。我认为您一直在创建临时变量。

— 马特·布朗

15

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

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

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

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

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

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

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

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

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

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

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

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

— 格拉斯双
source

您为array_last函数提供了2种替代实现。对于第一个，您声明$array已复制，对于第二个则声明未复制。区别在哪里/为什么在第一个实现中而不是在第二个实现中复制它？

— Paul van Leeuwen，

1

@PaulvanLeeuwen我明白你为什么感到困惑。我试图澄清答案，这更好吗？

— Gras Double

10

未经测试：这行不通吗？

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

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

如果您需要钥匙，我想您应该这样做：

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

— TecBrat
source

9

我经常需要用它来处理堆栈，而且我总是感到困惑，因为没有本机函数可以不以某种形式操纵数组或其内部指针。

因此，我通常会附带一个util函数，该函数在关联数组上也可以安全使用。

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

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

— 苏
source

1

好消息，他们正在将其作为本机功能：-)您可以在此处关注它的发布计划：wiki.php.net/todo/php73（在撰写本文时预计于2018年12月13日发布）。

— Paul van Leeuwen，

9

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

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

基准测试

我迭代了1000次，获取了分别包含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...

我使用PHP 5.5.32版。

— 威斯汀92
source

使用$ array [array_keys（$ array）[count（array_keys（$ array））-1]怎么办？

— user2782001

hmm..array_keys似乎伸缩性很差。

— user2782001

1

实际上，对于大型数组（0.0002）弹出项目并将其放回原处，它的疯狂速度更快... $ val = $ ar [] = $ array_pop（$ ar）;

— user2782001 '16

1

@ Westy92您的单位在基准上似乎是错误的。您给出的最小数字是0.00031 ... 微秒，大约是0.3纳秒。这意味着如果您有一台新电脑，则测试需要一个时钟滴答运行。我猜你的意思是毫秒或什至秒。

— cesoid

1

这些值显然是错误的几个数量级。为什么仍然要关注性能？

— istepaniuk

6

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

— 阿吉思
source

1

此解决方案有效，但它更改了数组的内部指针，我认为这不是正确的方法。

— Unix，2016年

5

从PHP 7.3版开始，已经引入了函数array_key_first和array_key_last。

由于PHP中的数组不是严格的数组类型，即从索引0开始的固定大小的字段的固定大小集合，而是动态扩展的关联数组，因此很难处理具有未知键的位置，并且解决方法的效果也不佳。相反，实数数组将通过指针算术在内部进行快速寻址，并且最后一个索引在编译时已通过声明获知。

从7.3版开始，内置函数至少解决了第一个和最后一个位置的问题。这甚至可以在不对数组文字立即发出任何警告的情况下工作：

$first = array_key_first( [1, 2, 'A'=>65, 'B'=>66, 3, 4 ] );
$last  = array_key_last ( [1, 2, 'A'=>65, 'B'=>66, 3, 4 ] );

显然，最后一个值是：

$array[array_key_last($array)];

— Quasimodo的克隆
source

1

感谢您引起大家的注意。对于那些急于使用此功能的用户：请不要在撰写本文时将其作为RC。它计划于2018

— Paul van Leeuwen

1

这是个好消息。我刚刚在下面的答案中发布了polyfill / shim，这样人们就可以立即开始使用此语法。

— 马克·汤姆森

3

$lastValue = end(array_values($array))

没有修改$ array指针。这样可以避免

reset($array)

在某些情况下可能不需要。

— 维汉·维玛（Vihaan Verma）
source

3

为了我：

$last = $array[count($array) - 1];

与关联者：

$last =array_values($array)[count($array - 1)]

— 米尔科·帕格莱（Mirko Pagliai）
source

请为您的答案提供一些背景信息。

— 肖恩

2

@Shawn哪个上下文？不需要上下文。添加了关联数组的代码。

— Mirko Pagliai

3

最佳答案很好，但是正如@ paul-van-leeuwen和@ quasimodos-clone所述，PHP 7.3将引入两个新函数直接解决此问题-array_key_first（）和array_key_last（）。

您可以立即通过以下polyfill（或shim）函数开始使用此语法。

// Polyfill for array_key_last() available from PHP 7.3
if (!function_exists('array_key_last')) {
  function array_key_last($array) {
    return array_slice(array_keys($array),-1)[0];
  }
}

// Polyfill for array_key_first() available from PHP 7.3
if (!function_exists('array_key_first')) {
  function array_key_first($array) {
    return array_slice(array_keys($array),0)[0];
  }
}

// Usage examples:
$first_element_key   = array_key_first($array);
$first_element_value = $array[array_key_first($array)];

$last_element_key    = array_key_last($array);
$last_element_value  = $array[array_key_last($array)];

警告：这需要PHP 5.4或更高版本。

— 马克·汤姆森
source

2

为此，请避免使用E_STRICT且不会弄乱数组的内部指针，可以使用：

function lelement($array) {return end($array);}

$last_element = lelement($array);

lelement仅适用于副本，因此不会影响数组的指针。

— 达米妮
source

2

另一个解决方案：

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
$lastItem = $array[(array_keys($array)[(count($array)-1)])];
echo $lastItem;

— 朱塞佩·加洛
source

2

另一种可能的解决方案...

$last_element = array_reverse( $array )[0];

— 查尔斯·加里森
source

不使用关联数组似乎不足以让我失望。就质量而言，这个答案并不比该问题的许多其他答案差。我不明白为什么我此时至少看到2张反对票。（评分为-2）。无论如何，对我来说，这还不错。

— Paul van Leeuwen

2

怎么样：

current(array_slice($array, -1))

适用于关联数组
在$array == []（返回false）时有效
不会影响原始数组

— 布克·韦斯提（Bouke Versteegh）
source

2

使用以下逻辑，您可以轻松地从数组中获取最后一个元素

$array = array('a', 'b', 'c', 'd');
echo ($array[count($array)-1]);

通过使用下面的逻辑，不仅倒数第二个元素，而且还可以获得倒数第二个，倒数第三个等等。

对于倒数第二个元素，您只需要在上面的语句中传递数字2，例如：
echo（$ array [count（$ array）-2]）;

— 阿姆扎德·汗（Amzad Khan）
source

1

为了从Array获取最后一个值：

array_slice($arr,-1,1) ;

对于删除最后一个值形式数组：

array_slice($arr,0,count($arr)-1) ;

— 里沙卜
source

1

array_slice($arr,-1,1)将导致另一个数组的长度为1，而不是最后一个元素

— Vic

让我们举一个例子： $a=array("red","green","blue","yellow","brown"); print_r(array_slice($a,-1,1)); 结果：Array ( [0] => brown )

— Rishabh

1

只是： $last_element = end((array_values($array)))

不重置阵列，也不给出STRICT警告。

PS。由于投票最多的答案仍没有双括号，因此我提交了此答案。

— 大安
source

1

我认为这对所有现有答案都有一点改进：

$lastElement = count($array) > 0 ? array_values(array_slice($array, -1))[0] : null;

与相比，性能要好于end()或的解决方案array_keys()，尤其是对于大型阵列
不会修改数组的内部指针
不会尝试为空数组访问未定义的偏移量
对于空数组，索引数组，混合数组和关联数组将按预期工作

— 阿德尔玛
source

可悲的是，它不适用于关联数组，因为切片的单个项目可能具有命名键。

— Gras Double

您是对的，编辑后添加了一个修复程序（array_values在单个元素切片上）

— Adelmar

1

使用end（）函数。

$array = [1,2,3,4,5];
$last = end($array); // 5

— 布莱恩·伯纳克
source

1

请注意，此函数将数组的指针移到该位置。

— giovannipds

还请注意，这是8年前发布的答案。stackoverflow.com/a/3687368/1255289

— miken32 '19

1

如今，我更希望始终使用该帮助程序，如php.net/end answer所建议。

<?php
function endc($array) {
    return end($array);
}

$items = array('one','two','three');
$lastItem = endc($items); // three
$current = current($items); // one
?>

这将始终保持指针不变，我们将永远不必担心括号，严格的标准或其他任何问题。

— 乔凡尼普兹
source

上面已经提到：stackoverflow.com/a/45333947/1255289

— miken32 '19

0

注意：对于（PHP 7> = 7.3.0）， 我们可以使用array_key_last —获取数组的最后一个键

array_key_last ( array $array ) : mixed

参考：http : //php.net/manual/en/function.array-key-last.php

— 洛肯德·辛格
source

1

其他答案已经涵盖了这一点。

— miken32 '19

但是我比其他人更早回答了此问题

— lokender singh's

-1

如果要在数组循环中获取数组的最后一个元素怎么办？

以下代码将导致无限循环：

foreach ($array as $item) {
 $last_element = end($array);
 reset($array);
 if ($last_element == $item) {
   // something useful here
 }
}

对于非关联数组，该解决方案显然很简单：

$last_element = $array[sizeof ($array) - 1];
foreach ($array as $key => $item) {
 if ($last_element == $item) {
   // something useful here
 }
}

— 瓦迪姆·波德列夫斯基
source

2

我知道end（）和reset（）函数。我的评论与诸如foreach之类的循环有关，或者您无法使用这些函数，因为reset函数会重置循环中用于迭代的数组的内部指针。抱歉，这个问题更简单，我只想给出在项目中遇到的更高级的情况。最好的祝福。

— Vadim Podlevsky

这在很多方面都是错误的（重复数组，非严格比较...），并且在任何情况下都与问题无关。

— Tgr

使用end（$ array）函数获取最后一个元素，为什么您不必要使用循环？

— Mahak Choudhary

1

@MahakChoudhary我的评论是“如何在数组循环内进行某些操作的同时获取数组的最后一个元素的补充。使用end（）将重置innver指针并中断迭代循环。欢呼！

— Vadim Podlevsky

-1

$file_name_dm =  $_FILES["video"]["name"];    

                           $ext_thumb = extension($file_name_dm);

                            echo extension($file_name_dm); 
function extension($str){
    $str=implode("",explode("\\",$str));
    $str=explode(".",$str);
    $str=strtolower(end($str));
     return $str;
}

— 胡西·波拉德（Hussy Borad）
source

-1

自PHP 7.3起array_key_last可用

$lastEl = $myArray[array_key_last($myArray)];

— 塔加里克迪·贾库巴
source

已经在其他多个答案中提到了这一点。

— miken32 '19

-1

很简单

$array = array('a', 'b', 'c', 'd');
end($array)

— 贾斯曼·马拉迪亚（Jasmeen Maradeeya）
source

值得一提的是，如果您使用带间隙的数组，这会产生奇怪的行为。即$a = array(); $a[2] = 'c'; $a[1] = 'b'; echo end($a); 会回来b

— Simon Zyx

这是9年前发布的。stackoverflow.com/a/3687368/1255289

— miken32 '19

-1

我的简单解决方案，漂亮易懂。

array_reverse($array)[0];

— 阿尔珀·艾丁格尔
source

如此简单，它发布于3年前。stackoverflow.com/a/38977466/1255289

— miken32 '19