una ultimo saber remover primer obtener matriz manejo hacer extraer elemento datos como array 3x3 php arrays

saber - php remover ultimo elemento array



¿Cuál es la mejor manera de obtener el último elemento de una matriz sin eliminarla? (24)

¿Qué pasa con array_slice($array, -1) ? (Ver Manual: http://us1.php.net/array_slice )

array_slice() devuelve una matriz. Probablemente no sea lo que buscas. Quieres el elemento.

De acuerdo,

Lo sé todo acerca de array_pop() , pero eso elimina el último elemento. ¿Cuál es la mejor manera de obtener el último elemento de una matriz sin eliminarla?

EDITAR: 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

¿Qué sucede si desea obtener el último elemento de la matriz dentro del bucle de su matriz?

El siguiente código resultará en un bucle infinito:

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

La solución es obviamente simple para arreglos no asociativos:

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

A partir de la versión 7.3 de PHP, se han introducido las funciones array_key_first y array_key_last .

Dado que las matrices en PHP no son tipos de matrices estrictas, es decir, colecciones de tamaño fijo de campos de tamaño fijo que comienzan en el índice 0, sino matrices asociativas dinámicamente extendidas, el manejo de posiciones con claves desconocidas es difícil y las soluciones no funcionan muy bien. En contraste, los arreglos reales se direccionarían internamente mediante aritmética de punteros muy rápidamente y el último índice ya se conoce en el momento de la compilación por declaración.

Al menos el problema con la primera y la última posición se resuelve con las funciones integradas ahora desde la versión 7.3. Esto funciona incluso sin advertencias en los literales de matriz fuera de la caja:

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

Obviamente el último valor es:

$array[array_key_last($array)];

Corto y dulce.

Se me ocurrió una solución para eliminar el mensaje de error y preservar la forma de una sola línea y el rendimiento eficiente:

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

- solución previa

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

Nota: Los paréntesis adicionales son necesarios para evitar los PHP Strict standards: Only variables should be passed by reference .

Creo que esto es una ligera mejora en todas las respuestas existentes:

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

  • Funciona mejor que end() o soluciones usando array_keys() , especialmente con arreglos grandes
  • No modificará el puntero interno de la matriz.
  • No intentará acceder a un desplazamiento indefinido para matrices vacías
  • Funcionará como se espera para matrices vacías, matrices indexadas, matrices mixtas y matrices asociativas

En casi todos los idiomas con arrays, realmente no puedes equivocarte con A [A.size-1]. No puedo pensar en un ejemplo de un lenguaje con matrices basadas en 1 (en lugar de cero).

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

Las opciones ( <<option code>> s) que probaré son:

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

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

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

Para las pruebas, 7.2.10 contenedores docker 5.6.38 , 7.2.10 y 7.3.0RC1 como:

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

Cada combinación de los <<option code>> s y <<input code>> s mencionados anteriormente 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, var_dump el último último valor recuperado de la entrada de prueba e imprimirá la duración promedio de una iteración en femtosegundos (0.000000000000001 de un 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 || /=========================================================================================================================================================================================================================================================================================================================================================================================================================/

Los códigos F atal, W arning y N otice mencionados anteriormente 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

Sobre la base de esta salida saco las siguientes conclusiones:

  • las versiones más recientes de PHP funcionan mejor con la excepción de estas opciones que se hicieron 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 se 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 solo deben usarse para arreglos auto indexados :
    • opción .7. $x = $array[count($array)-1]; (debido al uso de la count )
    • opción .9. $x = $array[] = array_pop($array); (debido a la asignación de valor perdiendo 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 la 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)));
  • La nueva función array_key_last 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 esto (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 se usa la matriz como pila o como cola , puede hacer variaciones en la opción 9.

Las respuestas principales son excelentes, pero como mencionan @ paul-van-leeuwen y @ quasimodos-clone, PHP 7.3 introducirá dos nuevas funciones para resolver este problema directamente: array_key_first() y array_key_last() .

Puede comenzar a utilizar esta sintaxis hoy mismo con las siguientes funciones de relleno (o relleno).

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

Advertencia: Esto requiere PHP 5.4 o superior.

Necesito esto con bastante frecuencia para lidiar con las pilas, y siempre me sorprende que no haya una función nativa que lo haga sin manipular la matriz o su puntero interno de alguna forma.

Por lo general, llevo una función util que también es segura de usar en arreglos asociativos.

function array_last($array) { if (count($array) < 1) return null; $keys = array_keys($array); return $array[$keys[sizeof($keys) - 1]]; }

Otra solución:

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

Para hacer esto y evitar el E_STRICT y no meterse con el puntero interno de la matriz, puede utilizar:

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

El elemento solo funciona con una copia, por lo que no afecta al puntero de la matriz.

Para mi:

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

Con asociativos:

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

Para obtener el último elemento de una matriz, use:

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

Punto de referencia

Repetí 1,000 veces, tomando el último elemento de arreglos pequeños y grandes que contenía 100 y 50,000 elementos, respectivamente.

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

Usé la versión 5.5.32 de PHP.

Para obtener el último valor de Array:

array_slice($arr,-1,1) ;

Para eliminar el último valor de la matriz de formulario:

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

Qué tal si:

current(array_slice($array, -1))

  • Obras para matrices asociativas.
  • funciona cuando $array == [] (devuelve false )
  • no afecta a la matriz original

Si no le importa modificar el puntero interno (admite 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 y la función opera en una copia de la misma):

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

Tenga en cuenta que PHP produce copias "sobre la marcha", es decir, solo cuando es realmente necesario. El propio end() modifica la matriz, por lo que internamente se genera una copia de la matriz.


Por lo tanto, la siguiente alternativa es en realidad más rápida, ya que internamente no copia la matriz, solo hace un segmento:

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

Este "foreach / return" es una mejora para obtener de manera eficiente el primer artículo (y aquí solo).


Finalmente, la alternativa más rápida, pero solo para matrices indexadas:

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

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

No restablece la matriz y no da advertencias ESTRICTAS.

PD. Ya que la respuesta más votada aún no tiene el paréntesis doble, presenté esta respuesta.

Tratar

$myLastElement = end($yourArray);

Para restablecerlo (gracias @hopeseekr):

reset($yourArray);

Enlace al manual

@David Murdoch agregó: $myLastElement = end(array_values($yourArray));// and now you don''t need to call reset(). En E_STRICT esto produce la advertencia.

Strict Standards: Only variables should be passed by reference

Gracias o_O Tync y todos!

Una forma de evitar los errores de paso por referencia (por ejemplo, "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))));

Una solución más posible ...

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

end () proporcionará el último elemento de una matriz

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

no probado: no funcionaria esto?

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

Dado que la matriz devuelta por array_values ​​es fugaz, a nadie le importa si se reinicia el puntero.

y si necesitas la llave para hacerlo, supongo que harías:

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

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

$lastValue = end(array_values($array))

No se realiza ninguna modificación en los punteros $ array. Esto evita la

reset($array)

Lo que podría no ser deseable en ciertas condiciones.