wake-up-neo.com

Was ist der beste Weg, um das letzte Element eines Arrays abzurufen, 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 abzurufen, 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
348

Kurz und bündig.

Ich habe eine Lösung gefunden, um die Fehlermeldung zu entfernen und das One-Liner-Format und die effiziente Leistung zu erhalten:

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

- bisherige Lösung

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

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

171
rolacja

Versuchen 

$myLastElement = end($yourArray);

Zurücksetzen (danke @hopeseekr):

 reset($yourArray);

Link zu manual

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

Strict Standards: Only variables should be passed by reference

Danke o_O Tync und allen!

454
Iznogood

Die vielen Antworten in diesem Thread bieten uns viele verschiedene Möglichkeiten. Um zwischen ihnen wählen zu können, musste ich ihr Verhalten und ihre Leistung verstehen. In dieser Antwort werde ich meine Ergebnisse mit Ihnen teilen, verglichen mit PHP Versionen 5.6.38, 7.2.10 und 7.3.0RC1 ( erwartet 13. Dez 2018 ).

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

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

Die Testeingaben (<<input code>>s) zur Kombination mit:

  • null$array = null;
  • _ = leer$array = [];
  • _ = last_null$array = ["a","b","c",null];
  • _ = auto_idx$array = ["a","b","c","d"];
  • _ = Shuffle$array = []; $array[1] = "a"; $array[2] = "b"; $array[0] = "c";
  • _ = 100$array = []; for($i=0;$i<100;$i++) { $array[] = $i; }
  • _ = 100000$array = []; for($i=0;$i<100000;$i++) { $array[] = $i; }

Zum Testen werde ich die Docker-Container 5.6.38, 7.2.10 und 7.3.0RC1PHP verwenden 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 Code-Snippet 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 Durchlauf wird var_dump der zuletzt abgerufene letzte Wert der Testeingabe und die durchschnittliche Dauer einer Iteration in Femtosekunden (0,00000000000000001stel Sekunde) ausgegeben.

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

Die oben genannten F atal, W arning und N iceice-Codes werden wie folgt übersetzt:

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 folgende Schlussfolgerungen:

  • neuere Versionen von PHP zeigen 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 von count)
    • option .9.$x = $array[] = array_pop($array); (wegen Wertzuweisung des ursprünglichen Schlü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 (leider skaliert er nicht für sehr große Arrays).
    • option .6.$x = end((array_values($array)));
  • die neue array_key_last-Funktion scheint keine der oben genannten Einschränkungen zu haben, mit der Ausnahme, dass zum Zeitpunkt dieses Schreibens noch eine RC vorhanden war (verwenden Sie also die RC oder warten Sie auf ihre Veröffentlichung Dezember 2018):
    • option 10.$x = $array[array_key_last($array)]; (seit PHP 7.3)

Ein bisschen, abhängig davon, ob das Array als Stapel oder als Warteschlange verwendet wird Sie können Variationen bei Option 9 vornehmen.

86

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. Du willst das Element.

34
Stoutie

Eine Möglichkeit, Fehler bei der Referenzübergabe (z. B. "end (array_values ​​($ foo))") zu vermeiden, 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))));
19
Warbo

ungeprüft: ... 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 sich niemand darum, ob der Zeiger zurückgesetzt wird.

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

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

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 Utility-Funktion wünschen, die den internen Zeiger nicht ändert (weil das Array als Wert übergeben wird und die Funktion eine Kopie davon ausführt):

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

Beachten Sie, dass PHP Kopien "on-the-fly" erzeugt, d. H. Nur wenn sie tatsächlich benötigt werden. Da end() das Array selbst ändert, wird intern eine Kopie des Arrays generiert.


Daher ist die folgende Alternative tatsächlich schneller, da intern das Array 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 ein Tweak, um effizient das erste (und hier einzelne) Element zu erhalten.


Schließlich die schnellste Alternative, aber nur für indizierte Arrays:

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



Hier ist eine andere Antwort von mir , für das erste Element des Arrays.

9
Gras Double

Ich brauche das oft, um mit Stapeln fertig zu werden, und ich finde es immer wieder verwirrt, 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, die auch sicher auf assoziativen Arrays verwendet werden kann.

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

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

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

Um das letzte Element eines Arrays abzurufen, verwenden Sie:

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

Benchmark

Ich wiederholte mich 1.000 Mal und schnappte mir das letzte Element von kleinen und großen Arrays, die 100 bzw. 50.000 Elemente enthielten.

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.

5
Westy92

Für mich:

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

Mit assoziativen:

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

Ab PHP Version 7.3 wurden die Funktionen array_key_first und array_key_last eingeführt.

Da Arrays in PHP keine strengen Arraytypen sind, d. H. Sammlungen mit fester Größe, beginnend mit Index 0, aber dynamisch erweiterte assoziative Arrays, ist die Handhabung von Positionen mit unbekannten Schlüsseln schwierig und die Problemumgehungen funktionieren nicht gut. Im Gegensatz dazu würden reale Arrays sehr schnell über Zeigerarithmetik intern adressiert, und der letzte Index ist bereits zur Kompilierzeit durch Deklaration bekannt.

Zumindest das Problem mit der ersten und letzten Position wird seit Version 7.3 durch eingebaute Funktionen gelöst. Dies funktioniert sogar ohne Warnungen auf Array Literals out of the Box:

$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)];
2

Wie wäre es mit:

current(array_slice($array, -1))
  • arbeitet für assoziative Arrays
  • funktioniert, wenn $array == [] (gibt false zurück)
  • hat keinen Einfluss auf das ursprüngliche Array
2
Bouke Versteegh

Eine andere Lösung:

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

Verwenden Sie die Funktion end ().

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

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

array_key_last ( array $array ) : mixed

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

2
lokender singh

Um dies zu erreichen und den E_STRICT zu vermeiden und den internen Zeiger des Arrays nicht zu verwirren, 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.

2
Damiene Stewart

Eine weitere mögliche Lösung ...

$last_element = array_reverse( $array )[0];
2
$lastValue = end(array_values($array))

Es wird keine Änderung an $ Array-Zeigern vorgenommen. Das vermeidet das 

reset($array)

was unter bestimmten Bedingungen nicht erwünscht ist.

1
Vihaan Verma

Heutzutage würde ich es vorziehen, immer diesen Helfer zu haben, wie in einer php.net/end Antwort 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 so wie er ist und wir müssen uns nie um Klammern, strenge Standards oder was auch immer kümmern.

1
giovannipds

Um den letzten Wert von Array zu erhalten:

array_slice($arr,-1,1) ;

Zum Entfernen des letzten Wertes aus dem Array:

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

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

$lastElement = count($array) > 0 ? array_values(array_slice($array, -1))[0] : null;
  • Bietet bessere Ergebnisse als end() oder Lösungen, die array_keys() verwenden, insbesondere bei großen Arrays
  • Ändert den internen Zeiger des Arrays nicht
  • Versuchen Sie nicht, auf einen undefinierten Versatz für leere Arrays zuzugreifen
  • Funktioniert wie erwartet für leere Arrays, indizierte Arrays, gemischte Arrays und assoziative Arrays
1
Adelmar

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

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

PS. Da die am meisten gewählte Antwort immer noch nicht die doppelte Klammer ist, habe ich diese Antwort übermittelt.

1
Daan

Die wichtigsten 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 ()array_key_last () .

Sie können diese Syntax heute mit den folgenden Polyfill-Funktionen (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)];

Caveat: Dies erfordert PHP 5.4 oder höher.

1
Mark Thomson

Das letzte Element eines Arrays erhalten Sie mit der folgenden Logik

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

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

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

0
Amzad Khan

Ab PHP 7.3 ist dies verfügbar

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

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;
}
0
Hussy Borad