好的，
我对 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 版本 5.6.38、7.2.10 和 7.3.0RC1 (expected Dec 13 2018) 为基准。
我将测试的选项 (<<option code>>) 是：
选项1。 $x = array_values(array_slice($array, -1))[0]; （如 rolacja 所建议的）
选项 .2。 $x = array_slice($array, -1)[0]; （根据 Stoutie 的建议）
选项 0.3。 $x = array_pop((array_slice($array, -1))); （如 rolacja 所建议的）
选项 0.4。 $x = array_pop((array_slice($array, -1, 1))); （由 Westy92 建议）
选项 0.5。 $x = end($array);重置（$数组）； （由伊兹诺古德建议）
选项 0.6。 $x = end((array_values($array))); （由 TecBrat 建议）
选项 0.7。 $x = $array[count($array)-1]; （如 Mirko Pagliai 所建议）
选项 0.8。 $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; （根据 thrau 的建议）
选项 0.9。 $x = $array[] = array_pop($array); （如 user2782001 所建议）
选项 10. $x = $array[array_key_last($array)]; （正如 Quasimodo 的克隆所建议的那样；根据 PHP 7.3 提供）
（提及的函数：array_key_last、array_keys、array_pop、array_slice、array_values、count、end、reset）
要结合的测试输入 (<<input code>>s)：
空=$数组=空；
空 = $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 = $数组 = []; 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 docker containers，例如：
sudo docker run -it --rm php:5.6.38-cli-stretch php -r '<<<CODE HERE>>>'
上面列出的 <<option code>> 和 <<input code>> 的每个组合都将在所有版本的 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 最后检索到的测试输入的最后一个值，并打印一次迭代 in femtoseconds 的平均持续时间（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 ||
\=========================================================================================================================================================================================================================================================================================================================================================================================================================/
上述致命、警告和通知代码翻译为：
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)));选项 0.8。 $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
选项 0.6。 $x = end((array_values($array)));
选项 0.8。 $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
这些选项最适合非常大的阵列：选项 0.5。 $x = end($array);重置（$数组）；选项 0.7。 $x = $array[count($array)-1];选项 0.9。 $x = $array[] = array_pop($array);选项 10. $x = $array[array_key_last($array)]; （自 PHP 7.3 起）
选项 0.5。 $x = end($array);重置（$数组）；
选项 0.7。 $x = $array[count($array)-1];
选项 0.9。 $x = $array[] = array_pop($array);
选项 10. $x = $array[array_key_last($array)]; （自 PHP 7.3 起）
这些选项只能用于自动索引数组：选项 .7。 $x = $array[count($array)-1]; （由于使用计数）选项 0.9。 $x = $array[] = array_pop($array); （由于赋值丢失原始键）
选项 0.7。 $x = $array[count($array)-1]; （由于使用计数）
选项 0.9。 $x = $array[] = array_pop($array); （由于赋值丢失原始键）
此选项不保留数组的内部指针选项 0.5。 $x = end($array);重置（$数组）；
选项 0.5。 $x = end($array);重置（$数组）；
此选项是尝试修改选项 .5。保留数组的内部指针（但遗憾的是它不适用于非常大的数组）选项 0.6。 $x = end((array_values($array)));
选项 0.6。 $x = end((array_values($array)));
新的 array_key_last 函数似乎没有上述任何限制，除了在撰写本文时仍然是 RC（所以使用 RC 或等待它在 2018 年 12 月发布）：选项 10. $x = $array[array_key_last ($array)]; （自 PHP 7.3 起）
选项 10. $x = $array[array_key_last($array)]; （自 PHP 7.3 起）
有点取决于 using the array as stack or as queue 您是否可以对选项 9 进行更改。
$array[array_key_last($array)]; 到您的基准。完成后请给我一些通知。我想比较一下性能结果。
短而甜。
我想出了解决方案来删除错误消息并保留单行形式和高效性能：
$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。
$array = array_slice($array, -1); $lastEl = array_pop($array); 我个人认为这更好（没有解析器“错误”）
array_size() > 1 是否 2. 检查数组是否实际上是一个数组。 我仍然坚持@Iznogood 的回答，因为 PHP 的内置 end() 函数已经以更有效的方式完成了所有的工作。
array_slice($array, -1) 有什么问题？ （参见手册：http://us1.php.net/array_slice）
array_slice() 返回一个数组。可能不是你要找的。你想要元素。
array_slice($array, -1)[0] 获取元素。
reset(array_slice($array, -1)) 是另一种方法（如果 array_slice() 返回任何“小于”单元素数组的内容，则不会导致错误）
array_slice($array, -1)[0] = "";
避免传递引用错误（例如“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))));
end((array_values($yourArray)))
call_user_func 技巧在 PHP 7 中也不起作用。我认为你坚持创建一个临时变量。
如果您不关心修改内部指针（以下行同时支持索引数组和关联数组）：
// 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;
作为记录，这里是 another answer of mine，表示数组的第一个元素。
array_last 函数提供了 2 个替代实现。首先，您声明 $array 已复制，而第二个声明未复制。区别在哪里/为什么在第一个实现中复制而不是在第二个实现中？
我经常需要这个来处理堆栈，而且我总是感到困惑，没有本地函数可以在不以某种形式操作数组或其内部指针的情况下完成它。
所以我通常会携带一个 util 函数，该函数也可以安全地用于关联数组。
function array_last($array) {
if (count($array) < 1)
return null;
$keys = array_keys($array);
return $array[$keys[sizeof($keys) - 1]];
}
未经测试：这不行吗？
<?php
$last_element=end(array_values($array));
?>
由于 array_values 返回的数组是短暂的，没有人关心它的指针是否被重置。
如果你需要钥匙，我想你会这样做：
<?php
$last_key=end(array_keys($array));
?>
php -r '$array=[1,2,3];echo end(array_values($array))."\n";' 顺便说一句，它会发出一个通知，所以这不是最好的方法：只有变量应该在第 1 行的命令行代码中通过引用传递
要获取数组的最后一个元素，请使用：
$lastElement = array_slice($array, -1)[0];
基准
我迭代了 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...
我使用了 PHP 版本 5.5.32。
自 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)];
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
为了我：
$last = $array[count($array) - 1];
与联想：
$last =array_values($array)[count($array - 1)]
怎么样：
current(array_slice($array, -1))
适用于关联数组
当 $array == [] 时有效（返回 false）
不影响原始数组
这个怎么样？
例如-
$arr = [1,2,3];
$lastElem = count($arr) ? $arr[count($arr) - 1] : null;
$lastValue = end(array_values($array))
没有对 $array 指针进行任何修改。这避免了
reset($array)
在某些情况下可能不需要。
另一种可能的解决方案...
$last_element = array_reverse( $array )[0];
最佳答案很棒，但正如 @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 或更高版本。
要做到这一点并避免 E_STRICT 并且不要弄乱数组的内部指针，您可以使用：
function lelement($array) {return end($array);}
$last_element = lelement($array);
lelement 仅适用于副本，因此它不会影响数组的指针。
从 Array 获取最后一个值：
array_slice($arr,-1,1) ;
对于从数组中删除最后一个值：
array_slice($arr,0,count($arr)-1) ;
array_slice($arr,-1,1) 将产生另一个长度为 1 的数组，而不是最后一个元素
$a=array("red","green","blue","yellow","brown"); print_r(array_slice($a,-1,1)); 结果：Array ( [0] => brown )
另一种解决方案：
$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
$lastItem = $array[(array_keys($array)[(count($array)-1)])];
echo $lastItem;
您将使用以下逻辑轻松地从数组中获取最后一个元素
$array = array('a', 'b', 'c', 'd');
echo ($array[count($array)-1]);
不仅是最后一个元素，您还可以使用以下逻辑获得倒数第二、倒数第三等。
对于倒数第二个元素，您必须在上述语句中仅传递数字 2，例如： echo ($array[count($array)-2]);
简单地说：$last_element = end((array_values($array)))
不重置阵列并且不给出 STRICT 警告。
PS。由于投票最多的答案仍然没有双括号，我提交了这个答案。
我认为这是对所有现有答案的轻微改进：
$lastElement = count($array) > 0 ? array_values(array_slice($array, -1))[0] : null;
比 end() 或使用 array_keys() 的解决方案执行得更好，尤其是对于大型数组
不会修改数组的内部指针
不会尝试访问空数组的未定义偏移量
对于空数组、索引数组、混合数组和关联数组将按预期工作
array_values）
现在，我更喜欢始终使用这个助手，正如 php.net/end answer 中所建议的那样。
<?php
function endc($array) {
return end($array);
}
$items = array('one','two','three');
$lastItem = endc($items); // three
$current = current($items); // one
?>
这将始终保持指针不变，我们将永远不必担心括号、严格标准或其他任何事情。
使用 end() 函数。
$array = [1,2,3,4,5];
$last = end($array); // 5
注意：对于 (PHP 7 >= 7.3.0) 我们可以使用 array_key_last — 获取数组的最后一个键
array_key_last ( array $array ) : mixed
参考：http://php.net/manual/en/function.array-key-last.php
这里的大多数解决方案对于非关联数组都是不可靠的，因为如果我们有一个最后一个元素为 false 的非关联数组，那么 end 和 current(array_slice($array, -1)) 也将返回 false，因此我们不能使用 false 作为空的未关联数组的指示符。
// end returns false form empty arrays
>>> $arr = []
>>> end($arr)
=> false
// last element is false, so end returns false,
// now we'll have a false possitive that the array is empty
>>> $arr = [1, 2, 3, false]
>>> end($arr)
=> false
>>> $arr = [1, 2, 3, false, 4]
>>> end($arr)
=> 4
current(array_slice($arr, -1)) 也是如此：
// returns false form empty arrays
>>> $arr = []
>>> current(array_slice($arr, -1))
=> false
// returns false if last element is false
>>> $arr = [1, 2, 3, false]
>>> current(array_slice($arr, -1))
=> false
>>> $arr = [1, 2, 3, false, 4]
>>> current(array_slice($arr, -1))
=> 4
最好的选择是使用可用于 PHP >= 7.3.0 或旧版本的 array_key_last，我们使用 count 来获取最后一个索引（仅适用于未关联的数组）：
// returns null for empty arrays
>>> $arr = []
>>> array_key_last($arr)
=> null
// returns last index of the array
>>> $arr = [1, 2, 3, false]
>>> array_key_last($arr)
=> 3
// returns last index of the array
>>> $arr = [1, 2, 3, false, 4]
>>> array_key_last($arr)
=> 4
对于旧版本，我们可以使用 count：
>>> $arr = []
>>> if (count($arr) > 0) $arr[count($arr) - 1]
// No excecution
>>> $arr = [1, 2, 3, false]
>>> if (count($arr) > 0) $arr[count($arr) - 1]
=> false
>>> $arr = [1, 2, 3, false, 4]
>>> if (count($arr) > 0) $arr[count($arr) - 1]
=> 4
这就是非关联数组的全部内容。如果我们确定我们有关联的数组，那么我们可以使用 end。
如果你想在它的数组的循环中获取数组的最后一个元素怎么办？
下面的代码将导致无限循环：
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
}
}
$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;
}
$myLastElement = end(array_values($yourArray));，现在您不需要调用reset()。end(array_values())将给出 E_STRICT：“只有变量应该通过引用传递”end((array_values($yourArray)))