Was ist der beste Weg, um das letzte Element eines Arrays zu erhalten, ohne es zu löschen?

OK,

Ich weiß alles über array_pop(), aber das löscht das letzte Element. Was ist der beste Weg, um das letzte Element eines Arrays zu erhalten, ohne es zu löschen?

EDIT: Hier ist ein Bonus:

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

oder auch

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

Die vielen Antworten in diesem Thread bieten uns viele verschiedene Möglichkeiten. Um aus ihnen auswählen zu können, musste ich ihr Verhalten und ihre Leistung verstehen. In dieser Antwort werde ich meine Erkenntnisse mit Ihnen, gebenchmarkt gegen PHP - Versionen gemeinsam nutzen 5.6.38, 7.2.10und 7.3.0RC1( voraussichtlich 13. Dezember 2018 ).

Die Optionen, die <<option code>>ich testen werde, sind:

• Option 1. $x = array_values(array_slice($array, -1))[0];( wie von rolacja vorgeschlagen )
• Option 2. $x = array_slice($array, -1)[0];( wie von Stoutie vorgeschlagen )
• Option .3. $x = array_pop((array_slice($array, -1)));( wie von rolacja vorgeschlagen )
• Option .4. $x = array_pop((array_slice($array, -1, 1)));( wie von Westy92 vorgeschlagen )
• Option .5. $x = end($array); reset($array);( wie von Iznogood vorgeschlagen )
• Option .6. $x = end((array_values($array)));( wie von TecBrat vorgeschlagen )
• Option .7. $x = $array[count($array)-1];( wie von Mirko Pagliai vorgeschlagen )
• Option .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];( wie von thrau vorgeschlagen )
• Option .9. $x = $array[] = array_pop($array);( wie von user2782001 vorgeschlagen )
• Option 10. $x = $array[array_key_last($array)]; ( wie vom Quasimodo-Klon vorgeschlagen ; verfügbar gemäß PHP 7.3)

(Erwähnte Funktionen: array_key_last , array_keys , array_pop , array_slice , array_values , count , end , reset )

Die <<input code>>zu kombinierenden Testeingänge:

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

Zum Testen ich das verwenden 5.6.38, 7.2.10und 7.3.0RC1 PHP Docker - Container wie:

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

Jede Kombination der oben aufgeführten <<option code>>s und <<input code>>s wird auf allen PHP-Versionen ausgeführt. Für jeden Testlauf wird das folgende Codefragment verwendet:

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

Bei jedem Lauf wird var_dump den zuletzt abgerufenen letzten Wert der Testeingabe ausgeben und die durchschnittliche Dauer einer Iteration in Femtosekunden (0,000000000000001stel Sekunde) ausgeben .

Die Ergebnisse sind wie folgt:

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

Das oben erwähnte F Atal, W arnung und N Otice Codes übersetzen , wie:

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

Basierend auf dieser Ausgabe ziehe ich die folgenden Schlussfolgerungen:

• Neuere Versionen von PHP bieten eine bessere Leistung mit Ausnahme dieser Optionen, die erheblich langsamer wurden:
  • Option .6. $x = end((array_values($array)));
  • Option .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
• Diese Optionen lassen sich am besten für sehr große Arrays skalieren:
  • Option .5. $x = end($array); reset($array);
  • Option .7. $x = $array[count($array)-1];
  • Option .9. $x = $array[] = array_pop($array);
  • Option 10. $x = $array[array_key_last($array)]; (seit PHP 7.3)
• Diese Optionen sollten nur für automatisch indizierte Arrays verwendet werden :
  • Option .7. $x = $array[count($array)-1];(aufgrund der Verwendung voncount)
  • Option .9. $x = $array[] = array_pop($array);(aufgrund der Zuweisung von Wertverlust des Originalschlüssels)
• Diese Option behält den internen Zeiger des Arrays nicht bei
  • Option .5. $x = end($array); reset($array);
• Diese Option ist ein Versuch, Option .5 zu ändern . um den internen Zeiger des Arrays zu erhalten (aber leider lässt er sich für sehr große Arrays nicht gut skalieren)
  • Option .6. $x = end((array_values($array)));
• Die neue array_key_lastFunktion scheint keine der oben genannten Einschränkungen zu haben, mit der Ausnahme, dass sie zum Zeitpunkt des Schreibens noch ein RC ist (verwenden Sie also den RC oder warten Sie auf die Veröffentlichung im Dezember 2018):
  • Option 10. $x = $array[array_key_last($array)]; (seit PHP 7.3)

Je nachdem, ob Sie das Array als Stapel oder als Warteschlange verwenden , können Sie Option 9 variieren .

Versuchen

$myLastElement = end($yourArray);

So setzen Sie es zurück (danke @hopeseekr):

 reset($yourArray);

Link zum Handbuch

@ David Murdoch fügte hinzu: $myLastElement = end(array_values($yourArray));// and now you don't need to call reset(). Auf E_STRICT wird die Warnung ausgegeben

Strict Standards: Only variables should be passed by reference

Danke o_O Tync und allen!

Kurz und bündig.

Ich habe eine Lösung gefunden, um Fehlermeldungen zu entfernen und die Einzeilerform und die effiziente Leistung beizubehalten:

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

- vorherige Lösung

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

Hinweis: Die zusätzlichen Klammern werden benötigt, um a zu vermeiden PHP Strict standards: Only variables should be passed by reference.

Was ist los mit array_slice($array, -1)? (Siehe Handbuch: http://us1.php.net/array_slice )

array_slice()gibt ein Array zurück. Wahrscheinlich nicht das, wonach Sie suchen. Sie wollen das Element.

Eine Möglichkeit, Referenzfehler zu vermeiden (z. B. "end (array_values ​​($ foo))"), ist die Verwendung von call_user_func oder 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))));

Wenn Sie den internen Zeiger nicht ändern möchten (unterstützt sowohl indizierte als auch assoziative Arrays):

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

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

Wenn Sie eine Dienstprogrammfunktion wünschen, die den internen Zeiger nicht ändert (da das Array als Wert übergeben wird und die Funktion eine Kopie davon bearbeitet):

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

Beachten Sie, dass PHP Kopien "on-the-fly" erstellt, dh nur, wenn sie tatsächlich benötigt werden. Das end()selbst ändert das Array, sodass intern eine Kopie des Arrays generiert wird.

Daher ist die folgende Alternative tatsächlich schneller, da das Array intern nicht kopiert wird, sondern nur ein Slice erstellt wird:

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

Dieses "foreach / return" ist eine Optimierung, um das erste (und hier einzelne) Element effizient zu erhalten.

Endlich die schnellste Alternative, aber nur für indizierte Arrays:

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

Für die Aufzeichnung ist hier eine andere Antwort von mir , für das erste Element des Arrays.

ungetestet: würde das nicht funktionieren?

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

Da das von array_values ​​zurückgegebene Array flüchtig ist, kümmert es niemanden, ob sein Zeiger zurückgesetzt wird.

und wenn Sie den Schlüssel dazu brauchen, würden Sie wahrscheinlich tun:

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

Ich brauche das ziemlich oft, um mit Stacks fertig zu werden, und ich bin immer verblüfft, dass es keine native Funktion gibt, die dies tut, ohne das Array oder seinen internen Zeiger in irgendeiner Form zu manipulieren.

Daher trage ich normalerweise eine util-Funktion mit mir herum, die auch auf assoziativen Arrays sicher verwendet werden kann.

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

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

Verwenden Sie Folgendes, um das letzte Element eines Arrays abzurufen:

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

Benchmark

Ich habe 1.000 Mal iteriert und das letzte Element kleiner und großer Arrays mit 100 bzw. 50.000 Elementen erfasst.

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

Ich habe PHP Version 5.5.32 verwendet.

end () liefert das letzte Element eines Arrays

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

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

Ab PHP Version 7.3 wurden die Funktionen array_key_firstund array_key_lasteingeführt.

Da Arrays in PHP keine strengen Array-Typen sind, dh Sammlungen von Feldern mit fester Größe ab Index 0, sondern dynamisch erweiterte assoziative Arrays, ist die Behandlung von Positionen mit unbekannten Schlüsseln schwierig und Problemumgehungen funktionieren nicht sehr gut. Im Gegensatz dazu würden reale Arrays sehr schnell intern über Zeigerarithmethik adressiert, und der letzte Index ist bereits zur Kompilierungszeit durch Deklaration bekannt.

Zumindest das Problem mit der ersten und letzten Position wird jetzt seit Version 7.3 durch eingebaute Funktionen gelöst. Dies funktioniert sogar ohne Warnungen bei sofort einsatzbereiten Array-Literalen :

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

Offensichtlich ist der letzte Wert :

$array[array_key_last($array)];

$lastValue = end(array_values($array))

$ Array-Zeiger werden nicht geändert. Dies vermeidet das

reset($array)

was unter bestimmten Bedingungen möglicherweise nicht erwünscht ist.

Für mich:

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

Mit Mitarbeitern:

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

Die besten Antworten sind großartig, aber wie von @ paul-van-leeuwen und @ quasimodos-clone erwähnt, wird PHP 7.3 zwei neue Funktionen einführen, um dieses Problem direkt zu lösen - array_key_first () und array_key_last () .

Sie können diese Syntax heute mit den folgenden Polyfill- (oder Shim-) Funktionen verwenden.

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

Vorsichtsmaßnahme: Dies erfordert PHP 5.4 oder höher.

Um dies zu tun und das E_STRICT zu vermeiden und nicht mit dem internen Zeiger des Arrays herumzuspielen, können Sie Folgendes verwenden:

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

$last_element = lelement($array);

lelement funktioniert nur mit einer Kopie, sodass der Zeiger des Arrays nicht beeinflusst wird.

Eine andere Lösung:

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

Noch eine mögliche Lösung ...

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

Wie wäre es mit:

current(array_slice($array, -1))

• funktioniert für assoziative Arrays
• funktioniert wenn $array == [](zurück false)
• wirkt sich nicht auf das ursprüngliche Array aus

Sie erhalten das letzte Element einfach aus einem Array, indem Sie die folgende Logik verwenden

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

Nicht nur das letzte Element, sondern Sie können auch das vorletzte, drittletzte usw. erhalten, indem Sie die folgende Logik verwenden.

Für das vorletzte Element müssen Sie in der obigen Anweisung nur die Nummer 2 übergeben, zum Beispiel:
echo ($ array [count ($ array) -2]);

So erhalten Sie den letzten Wert von Array:

array_slice($arr,-1,1) ;

Zum Entfernen des Formulararrays für den letzten Wert:

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

Einfach: $last_element = end((array_values($array)))

Setzt das Array nicht zurück und gibt keine STRICT-Warnungen aus.

PS. Da die am häufigsten gewählte Antwort immer noch nicht die doppelte Klammer enthält, habe ich diese Antwort eingereicht.

Ich denke, dies ist eine leichte Verbesserung gegenüber allen vorhandenen Antworten:

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

• Funktioniert besser als end()oder mit Lösungen array_keys(), insbesondere bei großen Arrays
• Der interne Zeiger des Arrays wird nicht geändert
• Es wird nicht versucht, auf einen undefinierten Offset für leere Arrays zuzugreifen
• Funktioniert wie erwartet für leere Arrays, indizierte Arrays, gemischte Arrays und assoziative Arrays

Verwenden Sie die Funktion end ().

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

Heutzutage würde ich es vorziehen, immer diesen Helfer zu haben, wie in einer Antwort von php.net/end vorgeschlagen .

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

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

Dadurch bleibt der Zeiger immer unverändert, und wir müssen uns nie um Klammern, strenge Standards oder was auch immer kümmern.

Hinweis: Für (PHP 7> = 7.3.0) können wir array_key_last verwenden - Ruft den letzten Schlüssel eines Arrays ab

array_key_last ( array $array ) : mixed

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

Was ist, wenn Sie das letzte Element des Arrays innerhalb der Schleife des Arrays erhalten möchten?

Der folgende Code führt zu einer Endlosschleife:

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

Die Lösung ist für nicht assoziative Arrays offensichtlich einfach:

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

Ab PHP 7.3 array_key_lastist verfügbar

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

Sehr einfach

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

meine einfache Lösung, hübsch und leicht zu verstehen.

array_reverse($array)[0];