Jaki jest najlepszy sposób na uzyskanie ostatniego elementu tablicy bez usuwania go?

Ok,

Wiem wszystko array_pop(), ale to usuwa ostatni element. Jaki jest najlepszy sposób na uzyskanie ostatniego elementu tablicy bez usuwania go?

EDYCJA: Oto bonus:

$array = array('a' => 'a', 'b' => 'b', 'c' => 'c');

lub nawet

$array = array('a', 'b', 'c', 'd');
unset($array[2]);
echo $array[sizeof($array) - 1]; // Output: PHP Notice:  Undefined offset:  2 in - on line 4

Wiele odpowiedzi w tym wątku przedstawia nam wiele różnych opcji. Aby móc z nich wybierać, musiałem zrozumieć ich zachowanie i wydajność. W tej odpowiedzi będę dzielić się z wami moimi odkryciami, na podstawie porównania z wersjami PHP 5.6.38, 7.2.10i 7.3.0RC1( oczekiwano 13 grudnia 2018 ).

Opcje <<option code>>, które przetestuję, to:

• opcja 1. $x = array_values(array_slice($array, -1))[0];( Jak sugerowano przez rolacja )
• Opcja 2. $x = array_slice($array, -1)[0];( Jak sugerowano przez Stoutie )
• opcja .3. $x = array_pop((array_slice($array, -1)));( Jak sugerowano przez rolacja )
• opcja .4. $x = array_pop((array_slice($array, -1, 1)));( Jak sugerowano przez Westy92 )
• opcja .5. $x = end($array); reset($array);( Jak sugerowano przez Iznogood )
• opcja .6. $x = end((array_values($array)));( Jak sugerowano przez TecBrat )
• opcja .7. $x = $array[count($array)-1];( Jak sugerowano przez Mirko Pagliai )
• opcja .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];( Jak sugerowano przez thrau )
• opcja .9. $x = $array[] = array_pop($array);( Jak sugerowano przez user2782001 )
• Opcja 10. $x = $array[array_key_last($array)]; ( jak sugerowano przez klon Quasimodo jest ; dostępny na PHP 7.3)

(wspomniane funkcje: array_key_last , array_keys , array_pop , array_slice , array_values , count , end , reset )

Wejścia testowe <<input code>>do połączenia z:

• null =$array = null;
• pusty =$array = [];
• last_null =$array = ["a","b","c",null];
• auto_idx =$array = ["a","b","c","d"];
• losowo =$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; }

Do testowania będę używać 5.6.38, 7.2.10i 7.3.0RC1 PHP pojemniki dokowane jak:

sudo docker run -it --rm php:5.6.38-cli-stretch php -r '<<<CODE HERE>>>'

Każda kombinacja wyżej wymienionych <<option code>>s i <<input code>>s będzie działać na wszystkich wersjach PHP. Do każdego uruchomienia testowego używany jest następujący fragment kodu:

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

Dla każdego przebiegu spowoduje to var_dump ostatnio pobraną ostatnią wartość wejścia testowego i wydrukowanie średniego czasu trwania jednej iteracji w femtosekundach (0,000000000000001 000 sekundy).

Wyniki są następujące:

/==========================================================================================================================================================================================================================================================================================================================================================================================================================\
||                                                                      ||                            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 ||
 \=========================================================================================================================================================================================================================================================================================================================================================================================================================/ 

Wyżej wymienione kody F atal, W arning i N otice tłumaczą się następująco:

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

Na podstawie tych wyników wyciągam następujące wnioski:

• nowsze wersje PHP działają lepiej, z wyjątkiem tych opcji, które stały się znacznie wolniejsze:
  • opcja .6. $x = end((array_values($array)));
  • opcja .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
• opcje te najlepiej skalują się dla bardzo dużych tablic:
  • opcja .5. $x = end($array); reset($array);
  • opcja .7. $x = $array[count($array)-1];
  • opcja .9. $x = $array[] = array_pop($array);
  • opcja 10. $x = $array[array_key_last($array)]; (od PHP 7.3)
• opcji tych należy używać tylko w przypadku tablic z autoindeksowaniem :
  • opcja .7. $x = $array[count($array)-1];(z powodu użyciacount)
  • opcja .9. $x = $array[] = array_pop($array);(z powodu przypisania utraconego klucza oryginalnego)
• ta opcja nie zachowuje wewnętrznego wskaźnika tablicy
  • opcja .5. $x = end($array); reset($array);
• ta opcja jest próbą modyfikacji opcji .5. aby zachować wewnętrzny wskaźnik tablicy (ale niestety nie skaluje się dobrze dla bardzo dużych tablic)
  • opcja .6. $x = end((array_values($array)));
• array_key_lastwydaje się, że nowa funkcja nie ma żadnego z wyżej wymienionych ograniczeń, z wyjątkiem tego, że w chwili pisania tego tekstu nadal jest RC (więc użyj RC lub poczekaj na wydanie Gru 2018):
  • opcja 10. $x = $array[array_key_last($array)]; (od PHP 7.3)

Nieco w zależności od tego, czy używasz tablicy jako stosu, czy jako kolejki , możesz wprowadzać zmiany w opcji 9.

Próbować

$myLastElement = end($yourArray);

Aby go zresetować (dzięki @hopeseekr):

 reset($yourArray);

Link do instrukcji

@David Murdoch dodał: $myLastElement = end(array_values($yourArray));// and now you don't need to call reset(). Na E_STRICT generuje to ostrzeżenie

Strict Standards: Only variables should be passed by reference

Dzięki o_O Tync i wszystkim!

Krótkie i słodkie.

Wymyśliłem rozwiązanie, aby usunąć komunikat o błędzie i zachować formę jednowarstwową i wydajną wydajność:

$lastEl = array_values(array_slice($array, -1))[0];

- poprzednie rozwiązanie

$lastEl = array_pop((array_slice($array, -1)));

Uwaga: dodatkowe nawiasy są potrzebne, aby uniknąć PHP Strict standards: Only variables should be passed by reference.

Co jest nie tak z array_slice($array, -1)? (Patrz Podręcznik: http://us1.php.net/array_slice )

array_slice()zwraca tablicę. Prawdopodobnie nie to, czego szukasz. Chcesz tego elementu.

Jednym ze sposobów uniknięcia błędów przekazywania przez odwołanie (np. „End (wartości_szablonu ($ foo))”) jest użycie call_user_func lub 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))));

Jeśli nie chcesz modyfikować wskaźnika wewnętrznego (obsługuje zarówno tablice indeksowane, jak i asocjacyjne):

// false if empty array
$last = end($array);

// null if empty array
$last = !empty($array) ? end($array) : null;

Jeśli potrzebujesz funkcji narzędzia, która nie modyfikuje wewnętrznego wskaźnika (ponieważ tablica jest przekazywana przez wartość, a funkcja działa na jej kopii):

function array_last($array) {
    if (empty($array)) {
        return null;
    }
    return end($array);
}

Zauważ, że PHP produkuje kopie „w locie”, tj. Tylko wtedy, gdy są rzeczywiście potrzebne. end()Sam zmienia tablicy więc wewnętrznie kopia tablicy jest generowany.

Zatem następująca alternatywa jest w rzeczywistości szybsza, ponieważ wewnętrznie nie kopiuje tablicy, po prostu tworzy plasterek:

function array_last($array) {
    if (empty($array)) {
        return null;
    }
    foreach (array_slice($array, -1) as $value) {
        return $value;
    }
}

Ten „foreach / return” to poprawka do skutecznego zdobycia pierwszego (i tutaj pojedynczego) przedmiotu.

Wreszcie najszybsza alternatywa, ale tylko dla indeksowanych tablic:

$last = !empty($array) ? $array[count($array)-1] : null;

Dla przypomnienia, oto moja kolejna odpowiedź na pierwszy element tablicy.

niesprawdzone: czy to nie zadziała?

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

Ponieważ tablica zwracana przez array_values ​​jest ulotna, nikogo to nie obchodzi, jeśli jej wskaźnik zostanie zresetowany.

i jeśli potrzebujesz klucza, aby to zrobić, myślę, że zrobiłbyś:

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

Potrzebuję tego dość często, aby radzić sobie ze stosami, i zawsze jestem zaskoczony, że nie ma natywnej funkcji, która by to zrobiła bez manipulowania tablicą lub jej wewnętrznym wskaźnikiem w jakiejś formie.

Więc zwykle noszę funkcję util, która jest również bezpieczna w przypadku tablic asocjacyjnych.

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

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

Aby uzyskać ostatni element tablicy, użyj:

$lastElement = array_slice($array, -1)[0];

Reper

Ierowałem 1000 razy, chwytając ostatni element małych i dużych tablic, które zawierały odpowiednio 100 i 50 000 elementów.

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

Użyłem PHP w wersji 5.5.32.

end () dostarczy ostatni element tablicy

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

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

Od wersji PHP 7.3 funkcje array_key_firsti array_key_lastzostały wprowadzone.

Ponieważ tablice w PHP nie są ścisłymi typami tablic, tj. Kolekcjami o stałych rozmiarach pól o stałej wielkości, zaczynającymi się od indeksu 0, ale dynamicznie rozszerzaną tablicą asocjacyjną, obsługa pozycji z nieznanymi kluczami jest trudna, a obejścia nie działają zbyt dobrze. Natomiast prawdziwe tablice byłyby bardzo szybko wewnętrznie adresowane za pomocą arytmetyki wskaźników, a ostatni indeks jest już znany w czasie kompilacji poprzez deklarację.

Przynajmniej problem z pierwszą i ostatnią pozycją jest rozwiązany przez wbudowane funkcje od wersji 7.3. Działa to nawet bez ostrzeżeń na literałach tablic po wyjęciu z pudełka:

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

Oczywiście ostatnia wartość to:

$array[array_key_last($array)];

$lastValue = end(array_values($array))

Nie dokonuje się modyfikacji wskaźników $ tablicowych. Pozwala to uniknąć

reset($array)

co może nie być pożądane w pewnych warunkach.

Dla mnie:

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

Dzięki inicjatywom:

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

Najlepsze odpowiedzi są świetne, ale jak wspomnieli @ paul-van-leeuwen i @ quasimodos-clone, PHP 7.3 wprowadzi dwie nowe funkcje bezpośredniego rozwiązania tego problemu - array_key_first () i array_key_last () .

Możesz zacząć korzystać z tej składni już dziś z następującymi funkcjami wypełniania (lub podkładki).

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

Uwaga: Wymaga PHP 5.4 lub nowszego.

Aby to zrobić i uniknąć E_STRICT i nie zadzierać z wewnętrznym wskaźnikiem tablicy, możesz użyć:

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

$last_element = lelement($array);

lelement działa tylko z kopią, więc nie wpływa na wskaźnik tablicy.

Inne rozwiązanie:

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

Jeszcze jedno możliwe rozwiązanie ...

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

Co powiesz na:

current(array_slice($array, -1))

• działa dla tablic asocjacyjnych
• działa, gdy $array == [](zwraca false)
• nie wpływa na oryginalną tablicę

Ostatni element z tablicy uzyskasz łatwo, korzystając z poniższej logiki

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

Nie tylko ostatni element, ale możesz także uzyskać drugi, trzeci i tak dalej, korzystając z poniższej logiki.

dla drugiego ostatniego elementu musisz przekazać tylko cyfrę 2 w powyższej instrukcji, na przykład:
echo ($ array [count ($ array) -2]);

Aby uzyskać ostatnią wartość z tablicy:

array_slice($arr,-1,1) ;

W celu usunięcia tablicy ostatniej wartości:

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

Po prostu: $last_element = end((array_values($array)))

Nie resetuje tablicy i nie wyświetla ostrzeżeń typu STRICT.

PS. Ponieważ najczęściej głosowana odpowiedź wciąż nie ma podwójnego nawiasu, przesłałem tę odpowiedź.

Myślę, że jest to niewielka poprawa w stosunku do wszystkich istniejących odpowiedzi:

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

• Działa lepiej niż end()przy użyciu rozwiązań array_keys(), szczególnie przy dużych tablicach
• Nie zmodyfikuje wewnętrznego wskaźnika tablicy
• Nie będzie próbował uzyskać dostępu do niezdefiniowanego przesunięcia dla pustych tablic
• Działa zgodnie z oczekiwaniami dla pustych tablic, tablic indeksowanych, tablic mieszanych i tablic asocjacyjnych

Użyj funkcji end ().

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

W dzisiejszych czasach wolałbym zawsze mieć tego pomocnika, jak sugerowano w odpowiedzi na php.net/end .

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

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

Dzięki temu wskaźnik pozostanie niezmieniony i nigdy nie będziemy musieli martwić się nawiasami, ścisłymi standardami lub czymkolwiek innym.

Uwaga: Dla (PHP 7> = 7.3.0) możemy użyć array_key_last - Pobiera ostatni klucz tablicy

array_key_last ( array $array ) : mixed

Patrz: http://php.net/manual/en/function.array-key-last.php

Co jeśli chcesz umieścić ostatni element tablicy w pętli jego tablicy?

Poniższy kod spowoduje powstanie nieskończonej pętli:

foreach ($array as $item) {
 $last_element = end($array);
 reset($array);
 if ($last_element == $item) {
   // something useful here
 }
}

Rozwiązanie jest oczywiście proste w przypadku tablic niekojarzonych:

$last_element = $array[sizeof ($array) - 1];
foreach ($array as $key => $item) {
 if ($last_element == $item) {
   // something useful here
 }
}

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

                           $ext_thumb = extension($file_name_dm);

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

Począwszy od PHP 7.3, array_key_lastjest dostępny

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

Bardzo prosta

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

moje proste rozwiązanie, ładne i łatwe do zrozumienia.

array_reverse($array)[0];