it-swarm.com.ru

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

В порядке,

Я знаю все о 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
363
Theodore R. Smith

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

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

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

185
rolacja

Пытаться

$myLastElement = end($yourArray);

Чтобы сбросить его (спасибо @hopeseekr):

 reset($yourArray);

Ссылка на руководство

@ Дэвид Мердок добавил: $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

Спасибо о_О Тынк и всем!

462
Iznogood

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

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

(упомянутые функции: array_key_last , array_keys , array_pop , array_slice , array_values , - количество , конец , сброс )

Тестовые входы (<<input code>>s) для объединения с:

  • null = $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";
  • 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контейнеры Docker 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 atal, W arning и N коды звонков переводятся как:

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.

95
Paul van Leeuwen

Что не так с array_slice($array, -1)? (См. Руководство: http://us1.php.net/array_slice )

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

35
Stoutie

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

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

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



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

11
Gras Double

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

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

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

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

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

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

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

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

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

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

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

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

7
Westy92

Начиная с 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)];
5
Quasimodo's clone
$lastValue = end(array_values($array))

В указатели $ array не вносятся изменения. Это позволяет избежать

reset($array)

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

3
Vihaan Verma

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

array_key_last ( array $array ) : mixed

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

3
lokender singh

Для меня:

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

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

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

Как насчет:

current(array_slice($array, -1))
  • работает для ассоциативных массивов
  • работает, когда $array == [] (возвращает false)
  • не влияет на исходный массив
2
Bouke Versteegh

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

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

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

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

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

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

$last_element = lelement($array);

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

2
Damiene Stewart

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

$last_element = array_reverse( $array )[0];
2
Charles Garrison

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

2
Mark Thomson

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

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

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

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

1
giovannipds

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

array_slice($arr,-1,1) ;

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

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

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

$lastElement = count($array) > 0 ? array_values(array_slice($array, -1))[0] : null;
  • Работает лучше, чем end() или решения, использующие array_keys(), особенно с большими массивами
  • Не будет изменять внутренний указатель массива
  • Не будет пытаться получить доступ к неопределенному смещению для пустых массивов.
  • Будет работать должным образом для пустых массивов, индексированных массивов, смешанных массивов и ассоциативных массивов.
1
Adelmar

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

Не сбрасывает массив и не выдает СТРОГО предупреждения.

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

1
Daan

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

$lastEl = $myArray[array_key_last($myArray)];
0
Tagarikdi Djakouba
$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;
}
0
Hussy Borad