Quelle est la meilleure façon d'obtenir le dernier élément d'un tableau sans le supprimer?

Question

Quelle est la meilleure façon d'obtenir le dernier élément d'un tableau sans le supprimer?

Ok,

je sais tout sur array_pop() , mais cela supprime le dernier élément. Quelle est la meilleure façon d'obtenir le dernier élément d'un tableau sans le supprimer?

EDIT: voici un bonus:

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

ou même

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

321

arrays php

demandé sur Westy92 2010-09-10 22:39:24

24 réponses

si vous ne vous souciez pas de modifier le pointeur interne (prend en charge les tableaux indexés et associatifs):

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

si vous voulez une fonction utilitaire qui ne modifie pas le pointeur interne (parce que le tableau est passé par la valeur, et la fonction fonctionne sur une copie de celui-ci):

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

notez que PHP produit des copies" à la volée", c'est-à-dire seulement lorsqu'elles sont réellement nécessaires. Le end() modifie lui-même le tableau, en interne, une copie du tableau est généré.

ainsi, l'alternative suivante est en fait plus rapide car en interne il ne copie pas le tableau, il fait juste une tranche:

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

Ce "foreach / retour" est un tweak pour efficacement l'obtention de la première (et unique) de l'élément.

enfin, l'alternative la plus rapide mais pour les tableaux indexés seulement:

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

5

répondu Gras Double 2018-10-05 20:22:46

pour moi:

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

avec associations:

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

3

répondu Mirko Pagliai 2016-11-15 20:28:54

pour ce faire et éviter L'E_STRICT et ne pas salir le pointeur interne du tableau, vous pouvez utiliser:

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

lelement ne fonctionne qu'avec une copie donc il n'affecte pas le pointeur du tableau.

2

répondu Damiene Stewart 2014-08-31 23:50:59

une autre solution:

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

2

répondu Giuseppe Gallo 2016-02-22 15:49:29

$lastValue = end(array_values($array))

aucune modification n'est faite aux pointeurs $array. Cela évite le

reset($array)

qui pourrait ne pas être souhaitable dans certaines conditions.

1

répondu Vihaan Verma 2013-09-25 21:05:22

pour obtenir la dernière valeur du tableau:

array_slice($arr,-1,1) ;

pour supprimer le tableau de la dernière valeur:

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

1

répondu Rishabh 2015-06-11 02:16:14

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

ne réinitialise pas le tableau et ne donne pas D'Avertissements stricts.

PS. Puisque la réponse la plus votée n'a toujours pas la double parenthèse, j'ai soumis cette réponse.

1

répondu Daan 2016-09-13 10:14:10

une autre solution possible...

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

1

répondu Charles Garrison 2016-11-18 00:46:17

Que Diriez-vous de:

current(array_slice($array, -1))

fonctionne pour les tableaux associatifs

fonctionne lorsque $array == [] (retourne false )

n'affecte pas le tableau original

1

répondu Bouke Versteegh 2017-01-09 22:09:20

je pense que c'est une légère amélioration par rapport à toutes les réponses existantes:

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

offre de meilleures performances que end() ou les solutions utilisant array_keys() , en particulier avec les grands réseaux

ne modifiera pas le pointeur interne du tableau

N'essaiera pas d'accéder à un décalage non défini pour les tableaux vides

fonctionnera comme prévu pour les tableaux vides, les tableaux indexés, les tableaux mixtes et les tableaux associatifs. tableaux

1

répondu Adelmar 2017-07-26 18:04:48

depuis la version 7.3 de PHP, les fonctions array_key_first et array_key_last ont été introduites.

puisque les tableaux en PHP ne sont pas des types de tableaux stricts, c'est-à-dire des collections de tailles fixes de champs de taille fixe commençant à l'index 0, mais un tableau associatif dynamiquement étendu, la manipulation de positions avec des clés inconnues est difficile et les solutions de rechange ne fonctionnent pas très bien. En revanche, les tableaux réels seraient traités à l'interne par l'arithmétique de pointeur très rapidement et le dernier index est déjà connu au moment de la compilation, par déclaration.

au moins le problème de la première et de la dernière position est résolu par des fonctions intégrées maintenant depuis la version 7.3. Cela fonctionne même sans aucun avertissement sur tableaux littéraux hors de la boîte:

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

évidemment la dernière valeur est:

$array[array_key_last($array)];

1

répondu Quasimodo's clone 2018-09-26 03:48:17

Que faire si vous voulez obtenir le dernier élément du tableau à l'intérieur de la boucle de son tableau?

le code ci-dessous résultera en une boucle infinie:

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

la solution est évidemment simple pour les matrices non associatives:

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

0

répondu Vadim Podlevsky 2012-01-12 16:19:31

$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

répondu Hussy Borad 2018-02-15 12:04:18

les meilleures réponses sont excellentes, mais comme l'ont mentionné @paul-van-leeuwen et @quasimodos-clone, PHP 7.3 va introduire deux nouvelles fonctions pour résoudre directement ce problème - array_key_first () et array_key_last () .

vous pouvez commencer à utiliser cette syntaxe aujourd'hui avec les fonctions polyfill (ou shim) suivantes.

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

mise en garde: cela nécessite PHP 5.4 ou plus.

0

répondu Mark Thomson 2018-10-05 21:12:41

dans presque toutes les langues avec des tableaux, vous ne pouvez pas vraiment vous tromper avec un[A. size-1]. Je ne peux pas penser à un exemple d'un langage avec 1 tableaux basés (par opposition à zéro basé).

-3

répondu Aaron Anodide 2010-09-10 18:44:25

score 141 · Answer 1

court et doux.

j'ai trouvé une solution pour supprimer le message d'erreur et préserver la forme monobloc et la performance efficace:

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

-- solution précédente

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

Note: les parenthèses supplémentaires sont nécessaires pour éviter un PHP Strict standards: Only variables should be passed by reference .

score 426 · Answer 2

Essayer

$myLastElement = end($yourArray);

pour le réinitialiser (merci @hopeseekr):

 reset($yourArray);

lien vers manuel

@David Murdoch a ajouté: $myLastElement = end(array_values($yourArray));// and now you don't need to call reset(). Sur E_STRICT cela produit l'avertissement

Strict Standards: Only variables should be passed by reference

Merci o_O Tync et tout le monde!

score 71 · Answer 3

les nombreuses réponses dans ce fil nous présentent de nombreuses options différentes. Pour pouvoir choisir parmi eux, j'avais besoin de comprendre leur comportement et leur performance. Dans cette réponse, je vais partager mes résultats avec vous, référencé par rapport aux versions PHP 5.6.38 , 7.2.10 et 7.3.0RC1 ( prévu le 13 décembre 2018 ).

les options ( <<option code>> s) que je vais tester sont:

option .1. $x = array_values(array_slice($array, -1))[0];
option .2. $x = array_slice($array, -1)[0];
option .3. $x = array_pop((array_slice($array, -1)));
option .4. $x = array_pop((array_slice($array, -1, 1)));
option .5. $x = end($array); reset($array);
option .6. $x = end((array_values($array)));
option .7. $x = $array[count($array)-1];
option .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; ( comme suggéré par thrau )
option .9. $x = $array[] = array_pop($array); ( comme suggéré par user2782001 )
option 10. $x = $array[array_key_last($array)]; ( comme suggéré par clone de Quasimodo ; disponible en PHP 7.3)

les entrées d'essai ( <<input code>> s) à combiner avec:

null = $array = null;
vide = $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; }

pour les tests j'utiliserai les 5.6.38 , 7.2.10 et 7.3.0RC1 Docker containers like:

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

chaque combinaison des <<option code>> s et <<input code>> s énumérés ci-dessus sera exécutée sur toutes les versions de PHP. Pour chaque essai l'extrait de code suivant est utilisé:

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

pour chaque exécution ceci var_dump la dernière valeur récupérée de la dernière valeur de l'entrée de test et imprimer la durée moyenne d'une itération en femtosecondes (0,0000000000001 th d'une seconde).

les résultats sont les suivants:

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

mentionnées ci-dessus F atal, W arning et N communication des codes traduire comme:

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

sur la base de ce résultat, je tire les conclusions suivantes:

les nouvelles versions de PHP fonctionnent mieux à l'exception de ces options qui sont devenues beaucoup plus lentes:
- option .6. $x = end((array_values($array)));
- option .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
ces options se dimensionnent le mieux pour les très grands tableaux:
- 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)]; (depuis PHP 7.3)
ces options ne doivent être utilisées que pour les tableaux indexés :
- option .7. $x = $array[count($array)-1]; (en raison de l'utilisation de count )
- option .9. $x = $array[] = array_pop($array); (en raison de l'attribution de la valeur perdre la clé d'origine)
cette option ne préserve pas le pointeur interne du tableau
- option .5. $x = end($array); reset($array);
cette option est une tentative de modifier l'option .5. pour préserver le pointeur interne du tableau (mais malheureusement il ne se balance pas bien pour les très grands tableaux)
- option .6. $x = end((array_values($array)));
la nouvelle fonction array_key_last ne semble avoir aucune des limitations mentionnées ci-dessus à l'exception d'être encore un RC au moment de la rédaction de cet article (utilisez donc le RC ou attendez sa sortie déc 2018):
- option 10. $x = $array[array_key_last($array)]; (depuis PHP 7.3)

un peu selon que en utilisant le tableau comme pile ou comme file vous pouvez faire des variations sur l'option 9.

score 33 · Answer 4

Qu'est-ce qui ne va pas avec array_slice($array, -1) ? (Voir manuel: http://us1.php.net/array_slice )

array_slice() retourne un tableau. Probablement pas ce que vous cherchez. Vous souhaitez l'élément.

score 19 · Answer 5

Une façon d'éviter de passer par les erreurs de référence (par exemple. "fin(array_values($foo))") est d'utiliser call_user_func ou 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))));

score 10 · Answer 6

non testé: ne serait-ce pas le travail?

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

puisque le tableau retourné par array_values est fugace, personne ne se soucie si son pointeur est réinitialisé.

et si vous avez besoin de la clé pour aller avec elle, je suppose que vous feriez:

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

score 8 · Answer 7

j'en ai besoin assez souvent pour traiter des piles, et je me trouve toujours déconcerté qu'il n'y a pas de fonction native qui le fait sans manipuler le tableau ou son pointeur interne sous une forme quelconque.

donc je transporte habituellement une fonction util qui est aussi sûre à utiliser sur les tableaux associatifs.

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

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

score 6 · Answer 8

fin() fournira le dernier élément d'un tableau

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

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

score 5 · Answer 9

Pour obtenir le dernier élément d'un tableau, utilisez:

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

de Référence", 151960920"

j'ai itéré 1.000 fois, saisissant le dernier élément de petits et grands tableaux qui contenaient respectivement 100 et 50.000 éléments.

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

j'ai utilisé la Version 5.5.32 de PHP.

score 5 · Answer 10

si vous ne vous souciez pas de modifier le pointeur interne (prend en charge les tableaux indexés et associatifs):

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

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

si vous voulez une fonction utilitaire qui ne modifie pas le pointeur interne (parce que le tableau est passé par la valeur, et la fonction fonctionne sur une copie de celui-ci):

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

notez que PHP produit des copies" à la volée", c'est-à-dire seulement lorsqu'elles sont réellement nécessaires. Le end() modifie lui-même le tableau, en interne, une copie du tableau est généré.

ainsi, l'alternative suivante est en fait plus rapide car en interne il ne copie pas le tableau, il fait juste une tranche:

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

Ce "foreach / retour" est un tweak pour efficacement l'obtention de la première (et unique) de l'élément.

enfin, l'alternative la plus rapide mais pour les tableaux indexés seulement:

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

score 3 · Answer 11

pour moi:

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

avec associations:

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

score 2 · Answer 12

pour ce faire et éviter L'E_STRICT et ne pas salir le pointeur interne du tableau, vous pouvez utiliser:

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

$last_element = lelement($array);

lelement ne fonctionne qu'avec une copie donc il n'affecte pas le pointeur du tableau.

score 2 · Answer 13

une autre solution:

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

score 1 · Answer 14

$lastValue = end(array_values($array))

aucune modification n'est faite aux pointeurs $array. Cela évite le

reset($array)

qui pourrait ne pas être souhaitable dans certaines conditions.

score 1 · Answer 15

pour obtenir la dernière valeur du tableau:

array_slice($arr,-1,1) ;

pour supprimer le tableau de la dernière valeur:

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

score 1 · Answer 16

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

ne réinitialise pas le tableau et ne donne pas D'Avertissements stricts.

PS. Puisque la réponse la plus votée n'a toujours pas la double parenthèse, j'ai soumis cette réponse.

score 1 · Answer 17

une autre solution possible...

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

1

répondu Charles Garrison 2016-11-18 00:46:17

score 1 · Answer 18

Que Diriez-vous de:

current(array_slice($array, -1))

fonctionne pour les tableaux associatifs
fonctionne lorsque $array == [] (retourne false )
n'affecte pas le tableau original

score 1 · Answer 19

je pense que c'est une légère amélioration par rapport à toutes les réponses existantes:

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

offre de meilleures performances que end() ou les solutions utilisant array_keys() , en particulier avec les grands réseaux
ne modifiera pas le pointeur interne du tableau
N'essaiera pas d'accéder à un décalage non défini pour les tableaux vides
fonctionnera comme prévu pour les tableaux vides, les tableaux indexés, les tableaux mixtes et les tableaux associatifs. tableaux

score 1 · Answer 20

depuis la version 7.3 de PHP, les fonctions array_key_first et array_key_last ont été introduites.

puisque les tableaux en PHP ne sont pas des types de tableaux stricts, c'est-à-dire des collections de tailles fixes de champs de taille fixe commençant à l'index 0, mais un tableau associatif dynamiquement étendu, la manipulation de positions avec des clés inconnues est difficile et les solutions de rechange ne fonctionnent pas très bien. En revanche, les tableaux réels seraient traités à l'interne par l'arithmétique de pointeur très rapidement et le dernier index est déjà connu au moment de la compilation, par déclaration.

au moins le problème de la première et de la dernière position est résolu par des fonctions intégrées maintenant depuis la version 7.3. Cela fonctionne même sans aucun avertissement sur tableaux littéraux hors de la boîte:

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

évidemment la dernière valeur est:

$array[array_key_last($array)];

score 0 · Answer 21

Que faire si vous voulez obtenir le dernier élément du tableau à l'intérieur de la boucle de son tableau?

le code ci-dessous résultera en une boucle infinie:

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

la solution est évidemment simple pour les matrices non associatives:

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

score 0 · Answer 22

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

score 0 · Answer 23

les meilleures réponses sont excellentes, mais comme l'ont mentionné @paul-van-leeuwen et @quasimodos-clone, PHP 7.3 va introduire deux nouvelles fonctions pour résoudre directement ce problème - array_key_first () et array_key_last () .

vous pouvez commencer à utiliser cette syntaxe aujourd'hui avec les fonctions polyfill (ou shim) suivantes.

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

mise en garde: cela nécessite PHP 5.4 ou plus.

score -3 · Answer 24

dans presque toutes les langues avec des tableaux, vous ne pouvez pas vraiment vous tromper avec un[A. size-1]. Je ne peux pas penser à un exemple d'un langage avec 1 tableaux basés (par opposition à zéro basé).

Las etiquetas más populares

Quelle est la meilleure façon d'obtenir le dernier élément d'un tableau sans le supprimer?

24 réponses