¿Cómo obtener el último elemento de una matriz sin eliminarlo?

15 minutos de lectura

Avatar de usuario de Theodore R. Smith
Teodoro R. Smith

OK,

lo se todo array_pop(), pero eso elimina el último elemento. ¿Cómo obtener el último elemento de una matriz sin eliminarlo?

Aquí hay una bonificación:

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

o incluso

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

  • Lo creas o no, abrirlo y volver a colocarlo es una de las formas más rápidas que he evaluado para hacer esto. $valor=$matriz[]=matriz_pop($matriz); echo $valor;

    – usuario2782001

    27 de junio de 2016 a las 16:36

  • Esta pregunta resultó en muchas opciones. Para ayudarme a elegir, hice una comparación de las opciones más notables/distintas y compartí los resultados como una respuesta separada. (:@user2782001 sugirió mi favorito hasta ahora en el comentario anterior. 🙂 ¡Gracias a todos por contribuir!

    –Paul van Leeuwen

    5 de febrero de 2017 a las 18:33

  • @TheodoreRSmith Cuando se lance PHP 7.3, podría considerar hacer (esta sugerencia del clon de Quasimodo la ‘respuesta aceptada’ (para su consideración) …

    –Paul van Leeuwen

    4 oct 2018 a las 11:55


Avatar de usuario de Paul van Leeuwen
Pablo van Leeuwen

Las muchas respuestas en este hilo nos presentan muchas opciones diferentes. Para poder elegir entre ellos necesitaba entender su comportamiento y desempeño. En esta respuesta, compartiré mis hallazgos con usted, comparados con las versiones de PHP 5.6.38, 7.2.10 y 7.3.0RC1 (esperado el 13 de diciembre de 2018).

Las opciones (<<option code>>s) Voy a probar son:

  • Opción 1. $x = array_values(array_slice($array, -1))[0]; (según lo sugerido por rolacja)
  • opcion 2. $x = array_slice($array, -1)[0]; (según lo sugerido por Stoutie)
  • opción .3. $x = array_pop((array_slice($array, -1))); (según lo sugerido por rolacja)
  • opción .4. $x = array_pop((array_slice($array, -1, 1))); (según lo sugerido por Westy92)
  • opción .5. $x = end($array); reset($array); (según lo sugerido por Iznogood)
  • opción .6. $x = end((array_values($array))); (según lo sugerido por TecBrat)
  • opción .7. $x = $array[count($array)-1]; (según lo sugerido por Mirko Pagliai)
  • opción .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]]; (según lo sugerido por thrau)
  • opción .9. $x = $array[] = array_pop($array); (según lo sugerido por user2782001)
  • opción 10. $x = $array[array_key_last($array)]; (como lo sugiere el clon de Quasimodo; disponible para PHP 7.3)

(funciones mencionadas: array_key_last , array_keys , array_pop , array_slice , valores_array , contar , final , Reiniciar)

Las entradas de prueba (<<input code>>s) para combinar con:

  • nulo = $array = null;
  • vacío = $array = [];
  • último_null = $array = ["a","b","c",null];
  • auto_idx = $array = ["a","b","c","d"];
  • barajar = $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; }

Para probar usaré el 5.6.38, 7.2.10 y 7.3.0RC1 Contenedores acoplables PHP me gusta:

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

Cada combinación de las anteriores <<option code>>arena <<input code>>s se ejecutará en todas las versiones de PHP. Para cada ejecución de prueba, se utiliza el siguiente fragmento de código:

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

Para cada ejecución, esto var_dump el último valor recuperado de la entrada de prueba e imprimirá la duración promedio de una iteración en femtosegundos (0.000000000000001 de segundo).

Los resultados son los siguientes:

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

El mencionado anteriormente Fatal, Wadvertencia y norteLos códigos de notificación se traducen como:

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

En base a este resultado llego a las siguientes conclusiones:

  • Las versiones más nuevas de PHP funcionan mejor con la excepción de estas opciones que se volvieron significativamente más lentas:
    • opción .6. $x = end((array_values($array)));
    • opción .8. $keys = array_keys($array); $x = $array[$keys[count($keys)-1]];
  • estas opciones escalan mejor para arreglos muy grandes:
    • opción .5. $x = end($array); reset($array);
    • opción .7. $x = $array[count($array)-1];
    • opción .9. $x = $array[] = array_pop($array);
    • opción 10. $x = $array[array_key_last($array)]; (desde PHP 7.3)
  • estas opciones deben solo se puede usar para matrices indexadas automáticamente:
    • opción .7. $x = $array[count($array)-1]; (debido al uso de count)
    • opción .9. $x = $array[] = array_pop($array); (debido a la asignación de valor perdiendo la clave original)
  • esta opción no conserva el puntero interno de la matriz
    • opción .5. $x = end($array); reset($array);
  • esta opción es un intento de modificar opción .5. para preservar el puntero interno de la matriz (pero lamentablemente no se escala bien para matrices muy grandes)
    • opción .6. $x = end((array_values($array)));
  • el nuevo array_key_last La función parece no tener ninguna de las limitaciones mencionadas anteriormente, con la excepción de que todavía es un RC en el momento de escribir este artículo (así que use el RC o espere su lanzamiento en diciembre de 2018):
    • opción 10. $x = $array[array_key_last($array)]; (desde PHP 7.3)

Un poco dependiendo de si usa la matriz como pila o como cola, puede hacer variaciones en la opción 9.

  • Muy buena respuesta, sin embargo, un comentario: para matrices asociativas, la opción 9 tampoco se puede usar, porque estamos asignando una clave indexada automáticamente en lugar del nombre de clave anterior.

    – Hierba Doble

    26 de julio de 2017 a las 5:52

  • Buen resumen! Agregue mi respuesta usando el nuevo PHP 7.3. función $array[array_key_last($array)]; a su punto de referencia. Y por favor dame alguna notificación cuando haya terminado. Me gustaría ver los resultados de rendimiento en comparación.

    – Clon de Quasimodo

    26 de septiembre de 2018 a las 3:55


  • @sz se produjo principalmente con mucha terquedad y paciencia, pero la selección general y las funciones de edición de varias líneas del editor de texto Sublime ayudaron. regenerarlo tomó casi un día, por lo que si necesito hacerlo nuevamente, probablemente escribiré algo que convierta la salida de las 210 ejecuciones de docker en una tabla automáticamente 🙂

    –Paul van Leeuwen

    29/09/2018 a las 20:07

  • @quasimodos-clone Regeneré toda la tabla en función de los últimos lanzamientos de PHP 5, 7 y su RC. Supongo que querremos generarlo nuevamente en diciembre, cuando se lance. Gracias por traer esta nueva función a la atención de todos.

    –Paul van Leeuwen

    29 sep 2018 a las 20:08

  • ¡Tres años después, cambié la Respuesta Aceptada por la tuya! ¡INCREÍBLE TRABAJO!

    – Theodore R. Smith

    5 de diciembre de 2019 a las 21:45

  • ¡Después de exactamente 5 años, 6 meses y 2 días, ha enviado una respuesta superior! ¡Gracias! y gracias Stack Overflow!!

    – Theodore R. Smith

    13 de marzo de 2016 a las 15:01

  • Salude la respuesta, pero agregar los paréntesis adicionales se siente un poco hackisch. También phpStorm marcará esto como un error. Información adicional para agregar paréntesis adicionales (phpsadness.com/sad/51). Para superar el error, podría convertir esto en ‘2 líneas’: $array = array_slice($array, -1); $lastEl = array_pop($array); Personalmente, creo que esto es mejor (sin el ‘error’ del analizador)

    – Mauricio

    23 de junio de 2016 a las 9:38

  • Puede usar la desreferenciación de esta manera: array_slice($array, -1)[0]

    – Vikash

    4 oct 2016 a las 12:24

  • No puede si tiene cadenas como índice en la matriz

    – rolacja

    8 de octubre de 2016 a las 6:45

  • Esta respuesta aún necesita al menos dos comprobaciones para evitar avisos de PHP. 1. comprobar si el array_size() > 1 2. Compruebe si la matriz es realmente una matriz. Todavía me atengo a la respuesta de @Iznogood como PHP incorporado end() función ya hace todo el trabajo duro de una manera más eficiente.

    – Ema4rl

    4 de diciembre de 2016 a las 23:43


Avatar de usuario de Stoutie
Stoutie

Qué hay de malo en array_slice($array, -1)? (Ver Manual: http://us1.php.net/array_slice)

array_slice() devuelve una matriz. Probablemente no sea lo que estás buscando. Quieres el elemento.

  • Usar array_slice($array, -1)[0] para obtener el elemento.

    – Pang

    19 de octubre de 2015 a las 4:28

  • Esta es la respuesta. “fin” ¿Cambiar el puntero interno de la matriz? Pidiendo problemas, y muy difícil de leer!

    – Gerard ONeill

    18 de diciembre de 2015 a las 15:03

  • Me encanta este enfoque, aunque como señala @Pang, no es del todo completo. reset(array_slice($array, -1)) es otro enfoque (que no causará un error si array_slice() devuelve algo “más pequeño” que una matriz de un solo elemento)

    – rinogo

    9 de febrero de 2016 a las 16:56

  • El mejor enfoque ya que puede modificar directamente el elemento: array_slice($array, -1)[0] = "";

    -Lorenzo Lapucci

    16 de noviembre de 2016 a las 10:14


Si no le importa modificar el puntero interno (las siguientes líneas admiten matrices indexadas y asociativas):

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

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

Si desea una función de utilidad que no modifique el puntero interno (porque la matriz se pasa por valor a la función, por lo que la función opera en una copia de ella):

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

Sin embargo, PHP produce copias “sobre la marcha”, es decir, sólo cuando realmente se necesitan. como el end() modifica la matriz, internamente se genera una copia de toda la matriz (menos un elemento).

Por lo tanto, recomendaría la siguiente alternativa que en realidad es más rápida, ya que internamente no copia la matriz, solo hace una porción:

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

Además, el “foreach / return” es un ajuste para obtener de manera eficiente el primer elemento (y aquí único).

Finalmente, la alternativa más rápida pero solo para matrices indexadas (y sin espacios):

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


Para que conste, aquí hay otra respuesta mía, para el primer elemento de la matriz.

  • Usar array_slice($array, -1)[0] para obtener el elemento.

    – Pang

    19 de octubre de 2015 a las 4:28

  • Esta es la respuesta. “fin” ¿Cambiar el puntero interno de la matriz? Pidiendo problemas, y muy difícil de leer!

    – Gerard ONeill

    18 de diciembre de 2015 a las 15:03

  • Me encanta este enfoque, aunque como señala @Pang, no es del todo completo. reset(array_slice($array, -1)) es otro enfoque (que no causará un error si array_slice() devuelve algo “más pequeño” que una matriz de un solo elemento)

    – rinogo

    9 de febrero de 2016 a las 16:56

  • El mejor enfoque ya que puede modificar directamente el elemento: array_slice($array, -1)[0] = "";

    -Lorenzo Lapucci

    16 de noviembre de 2016 a las 10:14


Avatar de usuario de Warbo
Warbo

Una forma de evitar errores de paso por referencia (p. ej., “end(array_values($foo))”) es usar call_user_func o 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))));

  • ¡Gran enfoque! (inserte el estándar ‘Esta debería ser la respuesta aceptada’ aquí)

    – error tipográfico

    17 de octubre de 2013 a las 8:54

  • O simplemente agregue un paréntesis adicional. Más corto y más dulce: end((array_values($yourArray)))

    – Dzhuneyt

    02/09/2014 a las 14:40

  • El truco del paréntesis adicional se basa en un error en PHP, y ese enfoque ya no funciona en versiones posteriores de PHP (o al menos, no en PHP 7).

    – Matt Browne

    6 mayo 2016 a las 19:29

  • Y el call_user_func truco tampoco funciona en PHP 7. Creo que estás atascado con la creación de una variable temporal.

    – Matt Browne

    6 mayo 2016 a las 19:34

¿Ha sido útil esta solución?