Хорошо,
Я знаю все о array_pop(), но удаляет последний элемент. Какой лучший способ получить последний элемент массива без его удаления?
EDIT: здесь бонус:
$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
Короткий и сладкий.
Я придумал решение для удаления сообщения об ошибке и сохранения однострочной формы и эффективной производительности:
$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.
Попробуйте
$myLastElement = end($yourArray);
В reset он (спасибо @hopeseekr):
reset($yourArray);
Ссылка на manual
@Дэвид Мердок добавил:
$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 и всем!
Многочисленные ответы в этой теме предоставляют нам множество различных вариантов. Чтобы иметь возможность выбирать из них, мне нужно было понять их поведение и производительность. В этом ответе я поделюсь с вами своими выводами, сопоставленными с версиями PHP 5.6.38, 7.2.10 и 7.3.0RC1 (ожидается 13 декабря 2018 г.).
Опции (<<option code>> s), которые я протестирую:
$x = array_values(array_slice($array, -1))[0]; (в соответствии с предложением Rolacja)$x = array_slice($array, -1)[0]; (как предложено Стути)$x = array_pop((array_slice($array, -1))); (в соответствии с предложением Rolacja)$x = array_pop((array_slice($array, -1, 1))); (как предложено Westy92)$x = end($array); reset($array); (как предложил Изногуд)$x = end((array_values($array))); (по предложению TecBrat)$x = $array[count($array)-1]; (по предложению Мирко Пальяи)$keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; (как предложено Thrau)$x = $array[] = array_pop($array); (как предложено пользователем 2782001)$x = $array[array_key_last($array)]; (как предложено Quasimodo clone; доступно в PHP 7.3)(упомянутые функции: array_key_last, array_keys, array_pop, array_slice, array_values, count, end, reset)
Тестовые входы (<<input code>> s) объединить с:
$array = null;$array = [];$array = ["a","b","c",null];$array = ["a","b","c","d"];$array = []; $array[1] = "a"; $array[2] = "b"; $array[0] = "c"; $array = []; $array[1] = "a"; $array[2] = "b"; $array[0] = "c";$array = []; for($i=0;$i<100;$i++) { $array[] = $i; } $array = []; for($i=0;$i<100;$i++) { $array[] = $i; }$array = []; for($i=0;$i<100000;$i++) { $array[] = $i; } $array = []; for($i=0;$i<100000;$i++) { $array[] = $i; } Для тестирования я буду использовать 5.6.38 7.2.10 PHP 5.6.38, 7.2.10 и 7.3.0RC1 такие как:
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 последнего полученного последнего значения входных данных теста и выводит среднюю продолжительность одной итерации в фемтосекундах (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 atal, W arning и N 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
На основании этого вывода я делаю следующие выводы:
$x = end((array_values($array)));$keys = array_keys($array); $x = $array[$keys[count($keys)-1]];$x = end($array); reset($array);$x = $array[count($array)-1];$x = $array[] = array_pop($array);$x = $array[array_key_last($array)]; (начиная с PHP 7.3)$x = $array[count($array)-1]; (из-за использования count)$x = $array[] = array_pop($array); (из-за присвоения значения потерянному оригинальному ключу)$x = end($array); reset($array);$x = end((array_values($array)));array_key_last похоже, не имеет ни одного из вышеупомянутых ограничений, за исключением того, что на момент написания этой статьи она все еще оставалась RC (поэтому используйте RC или дождитесь его выпуска в декабре 2018 года): $x = $array[array_key_last($array)]; (начиная с PHP 7.3)Немного в зависимости от того, используете ли массив как стек или как очередь, вы можете внести изменения в опцию 9.
Что случилось с array_slice($array, -1)? (См. Руководство: http://us1.php.net/array_slice)
array_slice() возвращает массив. Наверное, не то, что вы ищете. Вы хотите элемент.
Один из способов избежать ошибок при пересылке (например, "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 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))));
Если вам не нужно изменять внутренний указатель (поддерживает как индексированные, так и ассоциативные массивы):
// 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($value);
}
Обратите внимание, что 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;
Для записи, вот еще один мой ответ, для первого элемента массива.
непроверенных: не будет ли это работать?
<?php
$last_element=end(array_values($array));
?>
Поскольку массив, возвращаемый array_values, мимолетен, никто не заботится, указатель ли он reset.
и если вам нужен ключ для этого, я думаю, вы бы сделали:
<?php
$last_key=end(array_keys($array));
?>
Мне нужно это довольно часто, чтобы иметь дело со стеками, и я всегда сбиваюсь с толку, что нет никакой собственной функции, которая делает это без манипуляции с массивом или его внутренним указателем в той или иной форме.
Итак, я обычно ношу вокруг функции утилиты, которая также безопасна для использования в ассоциативных массивах.
function array_last($array) {
if (count($array) < 1)
return null;
$keys = array_keys($array);
return $array[$keys[sizeof($keys) - 1]];
}
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
Чтобы получить последний элемент массива, используйте:
$lastElement = array_slice($array, -1)[0];
эталонный тест
Я перебрал 1000 раз, взяв последний элемент из маленьких и больших массивов, которые содержали 100 и 50000 элементов соответственно.
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)];
$lastValue = end(array_values($array))
Никаких изменений в указателях $массива не производится. Это позволяет избежать
reset($array)
что может быть нежелательным в определенных условиях.
Для меня:
$last = $array[count($array) - 1];
С ассоциациями:
$last =array_values($array)[count($array - 1)]
Лучшие ответы хороши, но, как упоминали @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('a' => 'a', 'b' => 'b', 'c' => 'c');
$lastItem = $array[(array_keys($array)[(count($array)-1)])];
echo $lastItem;
Еще одно возможное решение...
$last_element = array_reverse( $array )[0];
Как насчет:
current(array_slice($array, -1))
$array == [] (возвращает false)Используйте функцию 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
Для получения последнего значения из массива:
array_slice($arr,-1,1) ;
Для удаления последнего массива формы значений:
array_slice($arr,0,count($arr)-1) ;
Просто: $last_element = end((array_values($array)))
Не содержит reset массив и не дает предупреждений STRICT.
PS. Поскольку у самого голосованного ответа все еще нет двойной круглой скобки, я представил этот ответ.
Я думаю, что это небольшое улучшение по всем существующим ответам:
$lastElement = count($array) > 0 ? array_values(array_slice($array, -1))[0] : null;
end() или решений с использованием array_keys(), особенно с большими массивамиВ настоящее время я предпочел бы всегда иметь этого помощника, как предложено в ответе на php.net/end.
<?php
function endc($array) {
return end($array);
}
$items = array('one','two','three');
$lastItem = endc($items); // three
$current = current($items); // one
?>
Это всегда будет держать указатель как есть, и нам никогда не придется беспокоиться о скобках, строгих стандартах или чем-то еще.
$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;
}
Начиная с PHP 7.3, array_key_last доступен
$lastEl = $myArray[array_key_last($myArray)];
Вы легко получите последний элемент из массива, используя приведенную ниже логику
$array = array('a', 'b', 'c', 'd');
echo ($array[count($array)-1]);
Не только последний элемент, но вы также можете получить второй последний, третий последний и т.д., используя логику ниже.
для второго последнего элемента вы должны передать только номер 2 в приведенном выше утверждении, например:
echo ($ array [count ($ array) -2]);
Очень просто
$array = array('a', 'b', 'c', 'd');
end($array)
Что делать, если вы хотите получить последний элемент массива внутри цикла его массива?
Следующий код приведет к бесконечному циклу:
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
}
}
В почти каждом языке с массивами вы не можете ошибиться с A [A.size-1]. Я не могу придумать пример языка с 1 базируемым массивом (в отличие от нуля).