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

Question

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

363

Хорошо,

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

Theodore R. Smith 10 сен. 2010, в 18:25

Источник

9

Хотите верьте, хотите нет, и снова наденьте это - один из самых быстрых способов сделать это. $ = $ Val массив [] = array_pop ($ массив); echo $ val;
user2782001 27 июнь 2016, в 16:36
2

Этот вопрос привел ко многим вариантам. Чтобы помочь себе выбрать, я провел некоторое сравнение наиболее заметных / отличных вариантов и поделился результатами в виде отдельного ответа . (: @ user2782001 предложил мой любимый до сих пор в комментарии выше. :) Спасибо всем за участие!
Paul van Leeuwen 05 фев. 2017, в 18:33
1

@TheodoreRSmith Когда выйдет PHP 7.3, вы можете подумать о том, чтобы сделать ( это предложение клона Квазимодо « принятым ответом» (на ваше рассмотрение) ...
Paul van Leeuwen 04 окт. 2018, в 11:55

Показать ещё 1 комментарий

Теги:

php

arrays

27 ответов

473

Попробуйте

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

Iznogood 10 сен. 2010, в 20:08

1

Потрясающие! Очевидно, что я знаю о руководстве (поскольку я связался с ним в моем вопросе), но это МНОГО функций для анализа, и я пропустил это. Спасибо брат.
Theodore R. Smith 10 сен. 2010, в 18:42
0

@hopeseekr Я связал руководство, чтобы вы могли прочитать его запись для end () не потому, что я учил, что вы не знали об этом :) И это помогает другим, которые будут искать здесь тот же вопрос. Рад, что помог!
Iznogood 10 сен. 2010, в 18:44
2

Проблема с end ($ array) заключается в том, что он изменяет внутренний указатель массива так, чтобы он указывал на последний элемент, что может быть проблемой, в зависимости от деталей вашей реализации.
Wade Tandy 10 сен. 2010, в 18:44
5

конец ($ массив); сброса ($ массив); задача решена ;-)
Theodore R. Smith 10 сен. 2010, в 18:53
1

Второй ответ совершенно не работает для основанных на ключе массивов. На самом деле, нет ничего хорошего, кроме end (), насколько я знаю. Я отменил принятие этого ответа, пока вы не удалите вторую часть своего ответа.
Theodore R. Smith 10 сен. 2010, в 18:57
0

@hopeseekr отредактировал последний раз мой ответ. В любом случае я всегда заканчиваю () себя так, чтобы ответ отвечал больше, чем я думаю. Эй спасибо !!
Iznogood 10 сен. 2010, в 18:59
35

Используйте $myLastElement = end(array_values($yourArray)); и теперь вам не нужно вызывать reset() .
David Murdoch 07 апр. 2012, в 14:39
5

@DavidMurdoch Возможно, но это, безусловно, приводит к оттоку оперативной памяти и процессора, создавая временный массив для значений массива ...
Theodore R. Smith 05 май 2012, в 02:46
12

Если ваш сервер потребляет слишком много оперативной памяти, так что вызов одной простой дополнительной функции является прерывателем, я предлагаю вам еще раз проверить конфигурацию и ресурсы вашего сервера.
Chris Baker 02 июль 2012, в 19:16
2

end(array_values()) даст E_STRICT: «Только переменные должны передаваться по ссылке»
kolypto 29 нояб. 2012, в 00:57
30

Добавьте дополнительные скобки, чтобы избежать строгого предупреждения: end((array_values($yourArray)))
DanFromGermany 19 март 2014, в 14:04
3

Для тех, кто идет прямо к ответам и обычно не читает весь вопрос ... Сделайте себе одолжение и прочитайте весь вопрос ... OP знает о функции для использования array_pop () "Я знаю все о array_pop () «Но если вы не прочитаете до конца вопроса, вы можете подумать, что то, что обсуждается здесь, это просто способ получить последний элемент массива независимо от удаления. Надеюсь, что это может помочь некоторым другим выйти за пределы скорости.
mimoralea 03 сен. 2014, в 17:37
0

Только в PHP идиоматическая проверка элемента массива может вызвать побочный эффект.
Keeth 08 июль 2015, в 17:48
0

end () ожидает, что параметр 1 будет массивом
Yevgeniy Afanasyev 19 нояб. 2015, в 05:41
1

@YevgeniyAfanasyev Конечно, вы должны передать функции правильный массив. Ненулевой! Сначала проверьте, действительно ли ваш массив массив php.net/manual/en/function.is-array.php
Iznogood 30 нояб. 2015, в 17:16
0

Ну, через 5 с половиной лет кто-то написал лучший ответ. Я меняю свое согласие ...
Theodore R. Smith 13 март 2016, в 14:58
0

Вам не нужно вызывать end если вы итерируете массив с помощью foreach , так как он использует собственный внутренний указатель.
Binar Web 19 апр. 2018, в 09:42
1

end(&array) требует, чтобы массив передавался по ссылке, если вы используете его на сгенерированных на лету массивах, он выдаст уведомление, например, end(explode(' ', $str))
evilReiko 01 июль 2018, в 13:28
0

Так как это самый голосующий ответ на данный момент. Обратите внимание, что недавно (декабрь 2018 г.) появилась новая опция: $array[array_key_last($array)]; ( как предполагает клон Квазимодо ; доступно в PHP 7.3).
Paul van Leeuwen 05 янв. 2019, в 14:50
0

Обратите внимание, что аргумент / замечание о том, что reset() решает возможную проблему изменения внутреннего указателя, может быть неверным в зависимости от вашего контекста. Если вы полагаетесь на то, что внутренний указатель находится в определенном состоянии (например, потому что вы используете его во внешнем цикле для обхода массива, то любой метод, который перемещает внутренний указатель, может быть проблемой. reset() не обязательно перемещает указатель на состояние, в котором он находился до вызова end() (только если он был уже в начале массива до вызова end() .
Paul van Leeuwen 05 янв. 2019, в 14:51

Показать ещё 18 комментариев

85

Многочисленные ответы в этой теме предоставляют нам множество различных вариантов. Чтобы иметь возможность выбирать из них, мне нужно было понять их поведение и производительность. В этом ответе я поделюсь с вами своими выводами, сопоставленными с версиями 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.

Paul van Leeuwen 22 янв. 2017, в 21:16

0

Если вы обнаружите, что какая-то конкретная опция отсутствует, вы можете проверить ее самостоятельно, скопировав приведенные выше фрагменты кода, сравнив их с ранее протестированной опцией. Чтобы добавить опцию в этот список, необходимо повторно протестировать все комбинации для получения сопоставимых результатов производительности. Если у вас есть конкретный вариант, который, по вашему мнению, следует добавить, оставьте комментарий, я собираюсь добавить его (хотя это может занять некоторое время).
Paul van Leeuwen 04 фев. 2017, в 13:04
1

Я заканчиваю с вариантом № 7. Это просто, легко понять и быстро.
Meam 01 июль 2017, в 09:01
2

Большое вам спасибо за это <3
Tim Strijdhorst 18 июль 2017, в 16:26
1

Очень хороший ответ, хотя один комментарий: для ассоциативных массивов опция 9 также не может быть использована, потому что мы назначаем обратно автоматически индексируемому ключу вместо предыдущего имени ключа.
Gras Double 26 июль 2017, в 05:52
0

@GrasDouble Спасибо, и блин, ты прав. Я не использовал PHP много после написания этого ответа: - $. Есть ли у нас (предположительно) высокопроизводительные варианты для больших ассоциативных массивов?
Paul van Leeuwen 26 июль 2017, в 09:34
0

Самым быстрым из них является простое использование end() (если массив не скопирован, см. Github.com/laravel/framework/pull/20261 ). Если вы хотите сохранить внутренний указатель или менее худший выбор при копировании массива: foreach (array_slice($array, -1) as $item) { } , foreach сохраняет вызов функции.
Gras Double 26 июль 2017, в 09:58
0

Мне очень нравится ваша идея взять различные ответы и сравнить их, особенно в отношении производительности. К сожалению, SO не очень удобен для отображения таблиц.
Sybille Peters 12 янв. 2018, в 12:25
0

Отличная вещь, спасибо! С чем вы произвели эту грозную таблицу?
Sz. 12 фев. 2018, в 00:05
0

Самая большая проблема здесь с опцией 7 состоит в том, что предполагается, что все клавиши последовательные, без скачков и все числовые. Требуется только [10 => 'whatever'] чтобы разбить его с неопределенным индексом.
Victor Schröder 20 фев. 2018, в 22:14
1

Хорошее резюме! Пожалуйста, добавьте мой ответ, используя новый PHP 7.3. function $array[array_key_last($array)]; к вашему эталону. И, пожалуйста, дайте мне уведомление, когда закончите. Я хотел бы видеть результаты производительности в сравнении.
Quasimodo's clone 26 сен. 2018, в 03:55
1

@sz это было главным образом сделано с большим упорством и терпением, но общие функции выбора и многострочного редактирования Sublime текстового редактора помогли. восстановление заняло почти день, поэтому, если мне понадобится сделать это снова, я, вероятно, напишу что-то, что автоматически преобразует вывод всех 210 выполнений докера в таблицу :-)
Paul van Leeuwen 29 сен. 2018, в 20:07
1

@ quasimodos-clone Я восстановил всю таблицу на основе последней версии PHP 5, 7 и вашего RC. Я предполагаю, что мы захотим сгенерировать его снова в декабре, когда он будет выпущен. Спасибо за то, что обратили внимание на эту новую функцию.
Paul van Leeuwen 29 сен. 2018, в 20:08
0

Лучший ответ, всегда ответ на проблему зависит от контекста проблемы. Иногда вам может потребоваться удобочитаемость, иногда производительность, предупреждение и т. Д.
Diego Andrés Díaz Espinoza 18 окт. 2018, в 13:52

Показать ещё 11 комментариев

34

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

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

Stoutie 05 нояб. 2013, в 04:58

21

Используйте array_slice($array, -1)[0] чтобы получить элемент.
Pang 19 окт. 2015, в 04:28
2

Это ответ. "конец" Изменение внутреннего указателя массива? Просят неприятностей и очень трудно читать!
Gerard ONeill 18 дек. 2015, в 15:03
0

Люблю такой подход, хотя, как отмечает @Pang, он не совсем завершен. reset(array_slice($array, -1)) - другой подход (который не вызовет ошибку, если array_slice() вернет что-то «меньшее», чем одноэлементный массив)
rinogo 09 фев. 2016, в 16:56
0

Наилучший подход, так как вы можете напрямую изменить элемент: array_slice($array, -1)[0] = "";
HAlex 16 нояб. 2016, в 10:14

Показать ещё 2 комментария

19

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

Warbo 12 июль 2013, в 15:51

0

Отличный подход! (вставьте стандарт «Это должен быть принятый ответ» здесь)
Typo 17 окт. 2013, в 08:54
3

Или просто добавьте дополнительный паратез. Короче и слаще: end((array_values($yourArray)))
Dzhuneyt 02 сен. 2014, в 14:40
4

Трюк с дополнительными скобками основан на ошибке в PHP, и этот подход больше не работает в более поздних версиях PHP (или, по крайней мере, не в PHP 7).
Matt Browne 06 май 2016, в 19:29
1

И трюк call_user_func также не работает в PHP 7. Я думаю, что вы застряли с созданием временной переменной.
Matt Browne 06 май 2016, в 19:34

Показать ещё 2 комментария

10

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

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

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

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

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

TecBrat 08 фев. 2012, в 19:44

0

Я не OP, но мне кажется, это хорошее решение.
liljoshu 02 авг. 2016, в 20:42

8

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

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

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

Gras Double 26 июль 2017, в 18:27

0

Вы предоставляете 2 альтернативные реализации для функции array_last . Для первого вы утверждаете, что $array скопирован, а для второго он не копируется. В чем разница / почему она копируется в первой реализации, а не во второй?
Paul van Leeuwen 04 окт. 2018, в 11:44
1

@PaulvanLeeuwen Я понял, почему ты запутался. Я попытался уточнить ответ , это лучше?
Gras Double 05 окт. 2018, в 20:27
0

Спасибо, очень ясно и узнал что-то новое
Paul van Leeuwen 06 окт. 2018, в 21:15

Показать ещё 1 комментарий

8

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

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

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

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

thrau 21 нояб. 2011, в 00:11

1

Хорошая новость, они делают ее встроенной функцией :-) Вы можете следить за планированием ее выпуска здесь: wiki.php.net/todo/php73 (ожидается 13 декабря 2018 года на момент написания этой статьи).
Paul van Leeuwen 04 окт. 2018, в 11:40

6

end() предоставит последний элемент массива

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');
echo end($array); //output: c

$array1 = array('a', 'b', 'c', 'd');
echo end($array1); //output: d

Ajith 21 март 2016, в 12:34

1

Это решение работает, но оно меняет внутренний указатель массива, я не думаю, что это правильный путь.
UnixAgain 21 дек. 2016, в 03:48

5

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

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

Westy92 14 июнь 2016, в 05:48

0

как насчет использования $ array [array_keys ($ array) [count (array_keys ($ array)) - 1]]?
user2782001 27 июнь 2016, в 15:59
0

хм .. array_keys, кажется, масштабируется довольно плохо.
user2782001 27 июнь 2016, в 16:08
0

используя array_keys: я получил 0,003 для маленького массива и 6,6 для большого. Использование $ temp = array_combine (array_fill (0, count ($ ar), 0), $ ar); $ temp [count ($ temp) -1]; было 3,1 для большого и Использование array_values ($ ar) [count ($ ar) -1] было 3,3 для большого.
user2782001 27 июнь 2016, в 16:20
1

На самом деле, большой массив (0,0002) быстрее извлекает элемент и возвращает его обратно ... $ val = $ ar [] = $ array_pop ($ ar);
user2782001 27 июнь 2016, в 16:31
0

@ Westy92 Ваши юниты кажутся неправильными в тесте. Наименьшее число, которое вы даете, составляет 0,00031 ... микросекунд, что составляет около 0,3 наносекунд. Это будет означать, что вашему тесту потребовался один такт для запуска, если у вас новый компьютер. Я предполагаю, что вы имели в виду миллисекунды или даже секунды .
cesoid 18 июль 2016, в 20:12
0

Обратите внимание, что разыменование массива функций - это PHP 5.4+.
Tgr 22 окт. 2016, в 02:56
0

Значения явно на несколько порядков неверны. В любом случае, зачем концентрироваться на производительности?
istepaniuk 16 май 2018, в 08:29

Показать ещё 5 комментариев

3

Для меня:

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

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

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

Mirko Pagliai 15 нояб. 2016, в 18:17

0

Пожалуйста, предоставьте некоторый контекст для вашего ответа.
Shawn 15 нояб. 2016, в 19:54
2

@ Показать какой контекст? Не нужен контекст. Добавлен код для ассоциативных массивов.
Mirko Pagliai 15 нояб. 2016, в 20:30

2

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

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

Brian Berneker 25 дек. 2018, в 22:57

1

Просто обратите внимание, что эта функция перемещает указатель вашего массива в эту позицию.
giovannipds 10 янв. 2019, в 12:15

2

Начиная с версии PHP 7.3 были введены функции array_key_first и array_key_last.

Поскольку массивы в PHP - это не строгие типы массивов, то есть коллекции фиксированного размера, поля фиксированного размера, начинающиеся с индекса 0, а динамически расширенный ассоциативный массив, обработка позиций с неизвестными ключами трудна, и обходные пути не очень хороши. В противоположность этому, реальные массивы будут быстро обрабатываться через арифметику указателей, и последний индекс уже известен во время компиляции по объявлению.

По крайней мере, проблема с первой и последней позицией теперь решается встроенными функциями начиная с версии 7.3. Это даже работает без каких-либо предупреждений о литералах массива из коробки:

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

Очевидно, что последнее значение:

$array[array_key_last($array)];

Quasimodo's clone 26 сен. 2018, в 03:36

0

Спасибо, что обратили на это внимание всех. Для тех, кто хочет использовать это: пожалуйста, не думайте, что это RC на момент написания этой статьи. Выпуск запланирован на декабрь 2018 года.
Paul van Leeuwen 30 сен. 2018, в 19:23
0

Это отличные новости. Я только что опубликовал polyfill / shim в своем ответе ниже, чтобы люди могли сразу начать использовать этот синтаксис.
Mark Thomson 05 окт. 2018, в 21:10

2

Как насчет:

current(array_slice($array, -1))

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

Bouke Versteegh 09 янв. 2017, в 23:27

2

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

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

Giuseppe Gallo 22 фев. 2016, в 17:36

2

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

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

$last_element = lelement($array);

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

Damiene Stewart 01 сен. 2014, в 01:48

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 или выше.

Mark Thomson 05 окт. 2018, в 22:34

1

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

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

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

Adelmar 02 нояб. 2016, в 23:22

0

К сожалению, он не работает с ассоциативными массивами, потому что отдельный элемент среза может иметь именованный ключ.
Gras Double 26 июль 2017, в 17:43
0

Вы правы, отредактировано, чтобы добавить исправление ( array_values для одноэлементного среза)
Adelmar 26 июль 2017, в 18:05

1

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

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

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

Daan 13 сен. 2016, в 11:14

1

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

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

Charles Garrison 16 авг. 2016, в 14:42

1

Не будет работать с ассоциативными массивами.
Tgr 22 окт. 2016, в 02:49
0

Не работа с ассоциативными массивами не кажется мне достаточной причиной, чтобы понизить голос. По качеству этот ответ не хуже многих других ответов на этот вопрос. Я не понимаю, почему я вижу по крайней мере 2 понижения голосов в это время. (оценка -2). Во всяком случае, upvote для меня, это не так уж плохо.
Paul van Leeuwen 12 апр. 2017, в 20:57

1

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

array_slice($arr,-1,1) ;

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

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

Rishabh 11 июнь 2015, в 02:05

1

array_slice($arr,-1,1) приведет к другому массиву длиной 1, а не к последнему элементу
Vic 19 янв. 2016, в 08:01
0

Давайте рассмотрим пример: $a=array("red","green","blue","yellow","brown"); print_r(array_slice($a,-1,1)); Результат: Array ( [0] => brown )
Rishabh 19 янв. 2016, в 14:39

1

$lastValue = end(array_values($array))

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

reset($array)

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

Vihaan Verma 25 сен. 2013, в 22:14

0

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

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

Tagarikdi Djakouba 06 фев. 2019, в 23:53

0

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

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

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

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

giovannipds 10 янв. 2019, в 12:43

0

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

                           $ext_thumb = extension($file_name_dm);

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

Hussy Borad 15 фев. 2018, в 13:37

0

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

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

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

Vadim Podlevsky 12 янв. 2012, в 16:26

0

это слишком большой код, когда доступна простая функция
Nilesh patel 25 янв. 2013, в 07:30
2

Я знаю о функциях end () и reset (). Мой комментарий был связан с циклами, такими как foreach или while, где вы не можете использовать эти функции, потому что функция сброса сбрасывает внутренний указатель массива, который используется в цикле для итерации. Извините за это, вопрос был более простым, я просто хотел дать более сложную ситуацию, с которой я столкнулся в своем проекте. С наилучшими пожеланиями.
Vadim Podlevsky 28 янв. 2013, в 12:45
0

Это неправильно во многих отношениях (массивы с дубликатами, нестрогое сравнение ...) и в любом случае не имеет отношения к вопросу.
Tgr 22 окт. 2016, в 02:54
0

используйте функцию end ($ array), чтобы получить последний элемент, почему вы без необходимости используете циклы?
Mahak Choudhary 15 янв. 2019, в 05:41

Показать ещё 2 комментария

-4

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

Aaron Anodide 10 сен. 2010, в 19:01

19

Это может не работать в PHP, так как массивы PHP больше похожи на хэши. Рассмотрим unset($a[3]) . Теперь индексы $ a равны 0,1,2,4,5 а $a[count($a) - 1] дает индекс 4, а не 5. Это становится еще хуже, если у вас есть нечисловые ключи ...
meagar♦ 10 сен. 2010, в 18:48
5

Вы можете пойти не так. Допустим, вы удалили средний элемент, PHP не переиндексирует остальные элементы. Например, следующий код создаст неопределенное уведомление о смещении: $arr = array('a', 'b', 'c'); unset($arr[1]); echo $arr[count($arr)-1]; с $arr = array('a', 'b', 'c'); unset($arr[1]); echo $arr[count($arr)-1];
webbiedave 10 сен. 2010, в 18:49
1

@Meagar: сглаз !!
webbiedave 10 сен. 2010, в 18:50
2

@webbiedave Боже мой! Прекратите меня преследовать!
meagar♦ 10 сен. 2010, в 18:50
5

Cobol, Fortran, Lua и Smalltalk используют массивы на основе 1 ...
BlueRaja - Danny Pflughoeft 10 сен. 2010, в 18:53
1

VB по умолчанию использует массивы, основанные на 1, но это можно изменить; - /
Theodore R. Smith 10 сен. 2010, в 18:54
1

@hopeseeker: Это верно только в древнем VB (<= 6).
webbiedave 10 сен. 2010, в 18:57
0

вау, это поучительно Я предполагаю, что реализация массивов в PHP использует скрытый список.
Aaron Anodide 10 сен. 2010, в 19:00
0

@webbiedave ты имеешь в виду последний, который я использовал? : /
Theodore R. Smith 10 сен. 2010, в 19:02
3

@Gabriel на самом деле это хэш-карта под капотом.
Theodore R. Smith 10 сен. 2010, в 19:03
0

На самом деле это оба под капотом. Если бы это был только хэш-файл, он не сохранил бы пары ключ / значение ассоциативного массива по порядку.
Brilliand 31 июль 2013, в 22:17
2

Понижено, потому что PHP не всегда работает таким образом. Аргументация уже объяснена в комментариях выше.
Dzhuneyt 02 сен. 2014, в 14:42
0

В любом случае никто не использует unset . Upvote.
Nick Manning 29 янв. 2015, в 05:06

Показать ещё 11 комментариев

Ещё вопросы

Хотите верьте, хотите нет, и снова наденьте это - один из самых быстрых способов сделать это. $ = $ Val массив [] = array_pop ($ массив); echo $ val;
Этот вопрос привел ко многим вариантам. Чтобы помочь себе выбрать, я провел некоторое сравнение наиболее заметных / отличных вариантов и поделился результатами в виде отдельного ответа . (: @ user2782001 предложил мой любимый до сих пор в комментарии выше. :) Спасибо всем за участие!
@TheodoreRSmith Когда выйдет PHP 7.3, вы можете подумать о том, чтобы сделать ( это предложение клона Квазимодо « принятым ответом» (на ваше рассмотрение) ...
Потрясающие! Очевидно, что я знаю о руководстве (поскольку я связался с ним в моем вопросе), но это МНОГО функций для анализа, и я пропустил это. Спасибо брат.
@hopeseekr Я связал руководство, чтобы вы могли прочитать его запись для end () не потому, что я учил, что вы не знали об этом :) И это помогает другим, которые будут искать здесь тот же вопрос. Рад, что помог!
Проблема с end ($ array) заключается в том, что он изменяет внутренний указатель массива так, чтобы он указывал на последний элемент, что может быть проблемой, в зависимости от деталей вашей реализации.
конец ($ массив); сброса ($ массив); задача решена ;-)
Второй ответ совершенно не работает для основанных на ключе массивов. На самом деле, нет ничего хорошего, кроме end (), насколько я знаю. Я отменил принятие этого ответа, пока вы не удалите вторую часть своего ответа.
@hopeseekr отредактировал последний раз мой ответ. В любом случае я всегда заканчиваю () себя так, чтобы ответ отвечал больше, чем я думаю. Эй спасибо !!
Используйте $myLastElement = end(array_values($yourArray)); и теперь вам не нужно вызывать reset() .
@DavidMurdoch Возможно, но это, безусловно, приводит к оттоку оперативной памяти и процессора, создавая временный массив для значений массива ...
Если ваш сервер потребляет слишком много оперативной памяти, так что вызов одной простой дополнительной функции является прерывателем, я предлагаю вам еще раз проверить конфигурацию и ресурсы вашего сервера.
end(array_values()) даст E_STRICT: «Только переменные должны передаваться по ссылке»
Добавьте дополнительные скобки, чтобы избежать строгого предупреждения: end((array_values($yourArray)))
Для тех, кто идет прямо к ответам и обычно не читает весь вопрос ... Сделайте себе одолжение и прочитайте весь вопрос ... OP знает о функции для использования array_pop () "Я знаю все о array_pop () «Но если вы не прочитаете до конца вопроса, вы можете подумать, что то, что обсуждается здесь, это просто способ получить последний элемент массива независимо от удаления. Надеюсь, что это может помочь некоторым другим выйти за пределы скорости.
Только в PHP идиоматическая проверка элемента массива может вызвать побочный эффект.
end () ожидает, что параметр 1 будет массивом
@YevgeniyAfanasyev Конечно, вы должны передать функции правильный массив. Ненулевой! Сначала проверьте, действительно ли ваш массив массив php.net/manual/en/function.is-array.php
Ну, через 5 с половиной лет кто-то написал лучший ответ. Я меняю свое согласие ...
Вам не нужно вызывать end если вы итерируете массив с помощью foreach , так как он использует собственный внутренний указатель.
end(&array) требует, чтобы массив передавался по ссылке, если вы используете его на сгенерированных на лету массивах, он выдаст уведомление, например, end(explode(' ', $str))
Так как это самый голосующий ответ на данный момент. Обратите внимание, что недавно (декабрь 2018 г.) появилась новая опция: $array[array_key_last($array)]; ( как предполагает клон Квазимодо ; доступно в PHP 7.3).
Обратите внимание, что аргумент / замечание о том, что reset() решает возможную проблему изменения внутреннего указателя, может быть неверным в зависимости от вашего контекста. Если вы полагаетесь на то, что внутренний указатель находится в определенном состоянии (например, потому что вы используете его во внешнем цикле для обхода массива, то любой метод, который перемещает внутренний указатель, может быть проблемой. reset() не обязательно перемещает указатель на состояние, в котором он находился до вызова end() (только если он был уже в начале массива до вызова end() .
Если вы обнаружите, что какая-то конкретная опция отсутствует, вы можете проверить ее самостоятельно, скопировав приведенные выше фрагменты кода, сравнив их с ранее протестированной опцией. Чтобы добавить опцию в этот список, необходимо повторно протестировать все комбинации для получения сопоставимых результатов производительности. Если у вас есть конкретный вариант, который, по вашему мнению, следует добавить, оставьте комментарий, я собираюсь добавить его (хотя это может занять некоторое время).
Я заканчиваю с вариантом № 7. Это просто, легко понять и быстро.
Очень хороший ответ, хотя один комментарий: для ассоциативных массивов опция 9 также не может быть использована, потому что мы назначаем обратно автоматически индексируемому ключу вместо предыдущего имени ключа.
@GrasDouble Спасибо, и блин, ты прав. Я не использовал PHP много после написания этого ответа: - $. Есть ли у нас (предположительно) высокопроизводительные варианты для больших ассоциативных массивов?
Самым быстрым из них является простое использование end() (если массив не скопирован, см. Github.com/laravel/framework/pull/20261 ). Если вы хотите сохранить внутренний указатель или менее худший выбор при копировании массива: foreach (array_slice($array, -1) as $item) { } , foreach сохраняет вызов функции.
Мне очень нравится ваша идея взять различные ответы и сравнить их, особенно в отношении производительности. К сожалению, SO не очень удобен для отображения таблиц.
Отличная вещь, спасибо! С чем вы произвели эту грозную таблицу?
Самая большая проблема здесь с опцией 7 состоит в том, что предполагается, что все клавиши последовательные, без скачков и все числовые. Требуется только [10 => 'whatever'] чтобы разбить его с неопределенным индексом.
Хорошее резюме! Пожалуйста, добавьте мой ответ, используя новый PHP 7.3. function $array[array_key_last($array)]; к вашему эталону. И, пожалуйста, дайте мне уведомление, когда закончите. Я хотел бы видеть результаты производительности в сравнении.
@sz это было главным образом сделано с большим упорством и терпением, но общие функции выбора и многострочного редактирования Sublime текстового редактора помогли. восстановление заняло почти день, поэтому, если мне понадобится сделать это снова, я, вероятно, напишу что-то, что автоматически преобразует вывод всех 210 выполнений докера в таблицу :-)
@ quasimodos-clone Я восстановил всю таблицу на основе последней версии PHP 5, 7 и вашего RC. Я предполагаю, что мы захотим сгенерировать его снова в декабре, когда он будет выпущен. Спасибо за то, что обратили внимание на эту новую функцию.
Лучший ответ, всегда ответ на проблему зависит от контекста проблемы. Иногда вам может потребоваться удобочитаемость, иногда производительность, предупреждение и т. Д.
Используйте array_slice($array, -1)[0] чтобы получить элемент.
Это ответ. "конец" Изменение внутреннего указателя массива? Просят неприятностей и очень трудно читать!
Люблю такой подход, хотя, как отмечает @Pang, он не совсем завершен. reset(array_slice($array, -1)) - другой подход (который не вызовет ошибку, если array_slice() вернет что-то «меньшее», чем одноэлементный массив)
Наилучший подход, так как вы можете напрямую изменить элемент: array_slice($array, -1)[0] = "";
Отличный подход! (вставьте стандарт «Это должен быть принятый ответ» здесь)
Или просто добавьте дополнительный паратез. Короче и слаще: end((array_values($yourArray)))
Трюк с дополнительными скобками основан на ошибке в PHP, и этот подход больше не работает в более поздних версиях PHP (или, по крайней мере, не в PHP 7).
И трюк call_user_func также не работает в PHP 7. Я думаю, что вы застряли с созданием временной переменной.
Я не OP, но мне кажется, это хорошее решение.
Вы предоставляете 2 альтернативные реализации для функции array_last . Для первого вы утверждаете, что $array скопирован, а для второго он не копируется. В чем разница / почему она копируется в первой реализации, а не во второй?
@PaulvanLeeuwen Я понял, почему ты запутался. Я попытался уточнить ответ , это лучше?
Спасибо, очень ясно и узнал что-то новое
Хорошая новость, они делают ее встроенной функцией :-) Вы можете следить за планированием ее выпуска здесь: wiki.php.net/todo/php73 (ожидается 13 декабря 2018 года на момент написания этой статьи).
Это решение работает, но оно меняет внутренний указатель массива, я не думаю, что это правильный путь.
как насчет использования $ array [array_keys ($ array) [count (array_keys ($ array)) - 1]]?
хм .. array_keys, кажется, масштабируется довольно плохо.
используя array_keys: я получил 0,003 для маленького массива и 6,6 для большого. Использование $ temp = array_combine (array_fill (0, count ($ ar), 0), $ ar); $ temp [count ($ temp) -1]; было 3,1 для большого и Использование array_values ($ ar) [count ($ ar) -1] было 3,3 для большого.
На самом деле, большой массив (0,0002) быстрее извлекает элемент и возвращает его обратно ... $ val = $ ar [] = $ array_pop ($ ar);
@ Westy92 Ваши юниты кажутся неправильными в тесте. Наименьшее число, которое вы даете, составляет 0,00031 ... микросекунд, что составляет около 0,3 наносекунд. Это будет означать, что вашему тесту потребовался один такт для запуска, если у вас новый компьютер. Я предполагаю, что вы имели в виду миллисекунды или даже секунды .
Обратите внимание, что разыменование массива функций - это PHP 5.4+.
Значения явно на несколько порядков неверны. В любом случае, зачем концентрироваться на производительности?
Пожалуйста, предоставьте некоторый контекст для вашего ответа.
@ Показать какой контекст? Не нужен контекст. Добавлен код для ассоциативных массивов.
Просто обратите внимание, что эта функция перемещает указатель вашего массива в эту позицию.
Спасибо, что обратили на это внимание всех. Для тех, кто хочет использовать это: пожалуйста, не думайте, что это RC на момент написания этой статьи. Выпуск запланирован на декабрь 2018 года.
Это отличные новости. Я только что опубликовал polyfill / shim в своем ответе ниже, чтобы люди могли сразу начать использовать этот синтаксис.
К сожалению, он не работает с ассоциативными массивами, потому что отдельный элемент среза может иметь именованный ключ.
Вы правы, отредактировано, чтобы добавить исправление ( array_values для одноэлементного среза)
Не будет работать с ассоциативными массивами.
Не работа с ассоциативными массивами не кажется мне достаточной причиной, чтобы понизить голос. По качеству этот ответ не хуже многих других ответов на этот вопрос. Я не понимаю, почему я вижу по крайней мере 2 понижения голосов в это время. (оценка -2). Во всяком случае, upvote для меня, это не так уж плохо.
array_slice($arr,-1,1) приведет к другому массиву длиной 1, а не к последнему элементу
Давайте рассмотрим пример: $a=array("red","green","blue","yellow","brown"); print_r(array_slice($a,-1,1)); Результат: Array ( [0] => brown )
это слишком большой код, когда доступна простая функция
Я знаю о функциях end () и reset (). Мой комментарий был связан с циклами, такими как foreach или while, где вы не можете использовать эти функции, потому что функция сброса сбрасывает внутренний указатель массива, который используется в цикле для итерации. Извините за это, вопрос был более простым, я просто хотел дать более сложную ситуацию, с которой я столкнулся в своем проекте. С наилучшими пожеланиями.
Это неправильно во многих отношениях (массивы с дубликатами, нестрогое сравнение ...) и в любом случае не имеет отношения к вопросу.
используйте функцию end ($ array), чтобы получить последний элемент, почему вы без необходимости используете циклы?
Это может не работать в PHP, так как массивы PHP больше похожи на хэши. Рассмотрим unset($a[3]) . Теперь индексы $ a равны 0,1,2,4,5 а $a[count($a) - 1] дает индекс 4, а не 5. Это становится еще хуже, если у вас есть нечисловые ключи ...
Вы можете пойти не так. Допустим, вы удалили средний элемент, PHP не переиндексирует остальные элементы. Например, следующий код создаст неопределенное уведомление о смещении: $arr = array('a', 'b', 'c'); unset($arr[1]); echo $arr[count($arr)-1]; с $arr = array('a', 'b', 'c'); unset($arr[1]); echo $arr[count($arr)-1];
@webbiedave Боже мой! Прекратите меня преследовать!
Cobol, Fortran, Lua и Smalltalk используют массивы на основе 1 ...
VB по умолчанию использует массивы, основанные на 1, но это можно изменить; - /
@hopeseeker: Это верно только в древнем VB (<= 6).
вау, это поучительно Я предполагаю, что реализация массивов в PHP использует скрытый список.
@webbiedave ты имеешь в виду последний, который я использовал? : /
@Gabriel на самом деле это хэш-карта под капотом.
На самом деле это оба под капотом. Если бы это был только хэш-файл, он не сохранил бы пары ключ / значение ассоциативного массива по порядку.
Понижено, потому что PHP не всегда работает таким образом. Аргументация уже объяснена в комментариях выше.
В любом случае никто не использует unset . Upvote.

rolacja · Accepted Answer · 2016-03-12T14-11-00.000Z

172

Лучший ответ

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

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

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

rolacja 12 март 2016, в 14:11

27

Ровно через 5 лет, 6 месяцев и 2 дня вы отправили более качественный ответ !! Спасибо! и спасибо, переполнение стека!
Theodore R. Smith 13 март 2016, в 15:01
1

Приветствую ответ, но добавление лишних скобок кажется немного хакишом. Также phpStorm пометит это как ошибку. Дополнительная информация для добавления дополнительных скобок ( phpsadness.com/sad/51 ). Чтобы преодолеть ошибку, вы можете сделать это «2- $array = array_slice($array, -1); $lastEl = array_pop($array); »: $array = array_slice($array, -1); $lastEl = array_pop($array); Лично я думаю, что это лучше (без парсера 'ошибка')
mauricehofman 23 июнь 2016, в 09:38
0

Вы можете получить его как однострочное и без дополнительной переменной: $ lastEl = array_pop ($ lastEl = (array_slice ($ array, -1)));
rolacja 23 июнь 2016, в 15:56
3

Вы можете использовать разыменование следующим образом: array_slice ($ array, -1) [0]
Vikash 04 окт. 2016, в 12:24
0

Вы не можете, если у вас есть строки в качестве индекса в массиве
rolacja 08 окт. 2016, в 06:45
0

В PHP7 выдается предупреждение ( E_NOTICE поскольку в PHP7 нет E_STRICT ), даже если вы используете дополнительные паразиты.
Tgr 22 окт. 2016, в 03:42
0

Я отредактировал решение, которое теперь не выдает ошибку.
rolacja 16 нояб. 2016, в 13:33
3

Этот ответ все еще нуждается в по крайней мере двух проверках, чтобы избежать уведомлений PHP. 1. проверить, если array_size() > 1 2. Проверить, является ли массив на самом деле массивом. Я все еще придерживаюсь ответа @Iznogood, поскольку встроенная в PHP функция end() уже выполняет всю тяжелую работу более эффективным образом.
Ema4rl 04 дек. 2016, в 23:43
0

почему бы просто не использовать функцию end ()?
jhonatan teixeira 19 авг. 2018, в 14:36
0

@jhonatanteixeira, если вы используете внутренний указатель массивов для чего-то другого в более широком контексте, вы можете избежать использования end() ...
Paul van Leeuwen 04 окт. 2018, в 11:51

Показать ещё 8 комментариев