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

Question

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

rolacja · Accepted Answer

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.

Iznogood · Answer

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!

Paul van Leeuwen · Answer

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:

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

(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.0RC1 PHP 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 "
"; 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.

Stoutie · Answer

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.

Warbo · Answer

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

TecBrat · Answer

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

Gras Double · Answer

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.

thrau · Answer

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

Ajith · Answer

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

Westy92 · Answer

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.

Mirko Pagliai · Answer

Für mich:

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

Mit assoziativen:

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

Quasimodo&#39;s clone · Answer

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

Bouke Versteegh · Answer

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

Giuseppe Gallo · Answer

Eine andere Lösung:

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

Brian Berneker · Answer

Verwenden Sie die Funktion end ().

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

lokender singh · Answer

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

Damiene Stewart · Answer

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.

Charles Garrison · Answer

Eine weitere mögliche Lösung ...

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

Vihaan Verma · Answer

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

giovannipds · Answer

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.

Rishabh · Answer

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

Adelmar · Answer

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

Daan · Answer

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.

Mark Thomson · Answer

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.

Amzad Khan · Answer

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

Tagarikdi Djakouba · Answer

Ab PHP 7.3 ist dies verfügbar

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

Hussy Borad · Answer

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