Какой лучший способ получить последний элемент массива без его удаления?

Хорошо,

Я знаю все о 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

Ответ 1

Короткий и сладкий.

Я придумал решение для удаления сообщения об ошибке и сохранения однострочной формы и эффективной производительности:

$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.

Ответ 2

Попробуйте

$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 и всем!

Ответ 3

Многочисленные ответы в этой теме предоставляют нам множество различных вариантов. Чтобы иметь возможность выбирать из них, мне нужно было понять их поведение и производительность. В этом ответе я поделюсь с вами своими выводами, сопоставленными с версиями PHP 5.6.38, 7.2.10 и 7.3.0RC1 (ожидается 13 декабря 2018 г.).

Опции (<<option code>> s), которые я протестирую:

Опция 1. $x = array_values(array_slice($array, -1))[0]; (в соответствии с предложением Rolacja)
вариант .2. $x = array_slice($array, -1)[0]; (как предложено Стути)
вариант .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]; (по предложению Мирко Пальяи)
вариант .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; (как предложено Thrau)
вариант .9. $x = $array[] = array_pop($array); (как предложено пользователем 2782001)
вариант 10. $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 = [];
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"; $array = []; $array[1] = "a"; $array[2] = "b"; $array[0] = "c";
100= $array = []; for($i=0;$i<100;$i++) { $array[] = $i; } $array = []; for($i=0;$i<100;$i++) { $array[] = $i; }
100000= $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

На основании этого вывода я делаю следующие выводы:

более новые версии 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 года):
- вариант 10. $x = $array[array_key_last($array)]; (начиная с PHP 7.3)

Немного в зависимости от того, используете ли массив как стек или как очередь, вы можете внести изменения в опцию 9.

Ответ 4

Что случилось с array_slice($array, -1)? (См. Руководство: http://us1.php.net/array_slice)

array_slice() возвращает массив. Наверное, не то, что вы ищете. Вы хотите элемент.

Ответ 5

Один из способов избежать ошибок при пересылке (например, "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))));

Ответ 6

Если вам не нужно изменять внутренний указатель (поддерживает как индексированные, так и ассоциативные массивы):

// 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;

Для записи, вот еще один мой ответ, для первого элемента массива.

Ответ 7

непроверенных: не будет ли это работать?

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

Поскольку массив, возвращаемый array_values, мимолетен, никто не заботится, указатель ли он reset.

и если вам нужен ключ для этого, я думаю, вы бы сделали:

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

Ответ 8

Мне нужно это довольно часто, чтобы иметь дело со стеками, и я всегда сбиваюсь с толку, что нет никакой собственной функции, которая делает это без манипуляции с массивом или его внутренним указателем в той или иной форме.

Итак, я обычно ношу вокруг функции утилиты, которая также безопасна для использования в ассоциативных массивах.

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

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

Ответ 9

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

Ответ 10

Чтобы получить последний элемент массива, используйте:

$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.

Ответ 11

Начиная с версии 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)];

Ответ 12

$lastValue = end(array_values($array))

Никаких изменений в указателях $массива не производится. Это позволяет избежать

reset($array)

что может быть нежелательным в определенных условиях.

Ответ 13

Для меня:

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

С ассоциациями:

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

Ответ 14

Лучшие ответы хороши, но, как упоминали @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 или выше.

Ответ 15

Чтобы сделать это и избежать E_STRICT, а не беспорядок с внутренним указателем массива, вы можете использовать:

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

$last_element = lelement($array);

lelement работает только с копией, поэтому он не влияет на указатель массива.

Ответ 16

Другое решение:

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

Ответ 17

Еще одно возможное решение...

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

Ответ 18

Как насчет:

current(array_slice($array, -1))

работает для ассоциативных массивов
работает, когда $array == [] (возвращает false)
не влияет на исходный массив

Ответ 19

Используйте функцию end().

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

Ответ 20

Примечание: для (PHP 7> = 7.3.0) мы можем использовать array_key_last - получает последний ключ массива

array_key_last ( array $array ) : mixed

Ссылка: http://php.net/manual/en/function.array-key-last.php

Ответ 21

Для получения последнего значения из массива:

array_slice($arr,-1,1) ;

Для удаления последнего массива формы значений:

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

Ответ 22

Просто: $last_element = end((array_values($array)))

Не содержит reset массив и не дает предупреждений STRICT.

PS. Поскольку у самого голосованного ответа все еще нет двойной круглой скобки, я представил этот ответ.

Ответ 23

Я думаю, что это небольшое улучшение по всем существующим ответам:

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

Выполняется лучше end() или решений с использованием array_keys(), особенно с большими массивами
Не будет изменять внутренний указатель массива
Не пытайтесь получить доступ к смещению undefined для пустых массивов
Будет работать как ожидалось для пустых массивов, индексированных массивов, смешанных массивов и ассоциативных массивов.

Ответ 24

В настоящее время я предпочел бы всегда иметь этого помощника, как предложено в ответе на php.net/end.

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

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

Это всегда будет держать указатель как есть, и нам никогда не придется беспокоиться о скобках, строгих стандартах или чем-то еще.

Ответ 25

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

Ответ 26

Начиная с PHP 7.3, array_key_last доступен

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

Ответ 27

Вы легко получите последний элемент из массива, используя приведенную ниже логику

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

Не только последний элемент, но вы также можете получить второй последний, третий последний и т.д., используя логику ниже.

для второго последнего элемента вы должны передать только номер 2 в приведенном выше утверждении, например:
echo ($ array [count ($ array) -2]);

Ответ 28

Очень просто

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

Ответ 29

Что делать, если вы хотите получить последний элемент массива внутри цикла его массива?

Следующий код приведет к бесконечному циклу:

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
 }
}

Ответ 30

В почти каждом языке с массивами вы не можете ошибиться с A [A.size-1]. Я не могу придумать пример языка с 1 базируемым массивом (в отличие от нуля).