Funciones en PHP no tan usadas pero útiles

Funciones en PHP no tan usadas pero útiles

Incluso después de trabajar con PHP desde hace muchos años, a veces nos encontramos con funciones y funcionalidades o características de las que no eramos conscientes. Algunas pueden ser útiles pero no se usan mucho, ya sea por el tipo de proyecto o el nivel de tecnología que tengamos. En este artículo comentaré unas cuantas funciones y características de PHP que quizá no sabías.

Funciones en PHP con número arbitrario de argumentos

Seguro que ya sabes que PHP permite definir funciones con argumentos opcionales. Pero existe un método para permitir un numero arbitrario de argumentos en las funciones.

Ejemplo de función con argumentos opcionales:


// función con 2 argumentos opcionales
function foo($arg1 = '', $arg2 = '') {

	echo "arg1: $arg1n";
	echo "arg2: $arg2n";

}


foo('hello','world');
/* muestra
arg1: hello
arg2: world
*/

foo();
/* Muestra
arg1:
arg2:
*/

Ahora, vamos a construir una función que acepte cualquier número de argumentos. Esta vez vamos a utilizar func_get_args():

// si, la lista de argumentos va vacía
function foo() {

	// devuelve un array con todos los argumentos que se han pasado
	$args = func_get_args();

	foreach ($args as $k => $v) {
		echo "arg".($k+1).": $vn";
	}

}

foo();
/* no muestra nada */

foo('hello');
/* muestra
arg1: hello
*/

foo('hello', 'world', 'again');
/* muestra
arg1: hello
arg2: world
arg3: again
*/

Buscar y encontrar ficheros en PHP con GLob()

Muchas funciones en PHP tienen nombres largos y descriptivos, sin embargo es difícil saber que hace una función llamada glob(), a no ser que lo busques en la documentación o ya la hayas usado previamente.

Es una función mucho más potente que scandir() ya que también permite búsqueda de ficheros usando patrones.

// buscados todos los archivos con extensión .php, podría ser cualquier otra extensión.
$files = glob('*.php');

print_r($files);
/* los datos de salida serán algo similar a esto
Array
(
    [0] => phptest.php
    [1] => pi.php
    [2] => post_output.php
    [3] => test.php
)
*/

También se pueden extraer múltiples tipos de ficheros de la siguiente manera:

// sacamos todos los archivos con extensión .php y .txt
$files = glob('*.{php,txt}', GLOB_BRACE);

print_r($files);
/* los datos de salida se parecerán a los siguientes
Array
(
    [0] => phptest.php
    [1] => pi.php
    [2] => post_output.php
    [3] => test.php
    [4] => log.txt
    [5] => test.txt
)
*/

NOTA: Los archivos se pueden devolver con su ruta, dependiendo de la búsqueda que se haga


$files = glob('../images/a*.jpg');

print_r($files);
/* datos de salida
Array
(
    [0] => ../images/apple.jpg
    [1] => ../images/art.jpg
)
*/

Si quieres obtener la ruta completa de cada archivo, tendrías que llamar a la función realpath() en los valores retornados.

$files = glob('../images/a*.jpg');

// aplico la función a cada elemento del array
$files = array_map('realpath',$files);

print_r($files);
/* datos de salida
Array
(
    [0] => C:wampwwwimagesapple.jpg
    [1] => C:wampwwwimagesart.jpg
)
*/

Procesar con PHP información de la memoria usada

Monitorizando la memoria usada de tus scripts serás capaz de optimizar tu código mucho mejor. La monitorización ya sea en los servidores, base de datos o en nuestro código siempre es un práctica muy aconsejable de realizar y con la que tendremos una información valiosa de la calidad de nuestro software, con esta información se pueden hacer muchas “cosas” pero eso da para otro artículo.

PHP tiene un complejo administrador de memoria, La cantidad total de memoria que esta siendo usada por un script puede subir y bajar durante la ejecución del mismo. Para obtener la memoria usada en un determinado momento se tiene que usar la función memory_get_usage(), para conseguir la cantidad más alta de memoria usada a lo largo de la ejecución del script usar la función memory_get_peak_usage()

Pongamos a prueba el uso de la memoria con el siguiente ejemplo.

echo "Bytes iniciales: ".memory_get_usage()."n";
/* mostrará por ejemploo
Bytes iniciales: 361400
*/

// vamos a forzar el uso de memoria
for ($i = 0; $i < 100000; $i++) {
	$array []= md5($i);
}

// vamos a eliminar la mitad del array
for ($i = 0; $i < 100000; $i++) {
	unset($array[$i]);
}

echo "Final: ".memory_get_usage()." bytes n";
/* imprime
Final: 885912 bytes
*/

echo "Peak: ".memory_get_peak_usage()." bytes n";
/* imprime
Peak: 13687072 bytes
*/

NOTA: Es muy posible que no os van a dar los mismo resultados que a mi, porque el equipo donde ejecutáis vuestro código es diferente al mío, o incluso si fuera idéntico tampoco tendría porque salir lo mismo. Todo depende de la memoria que vaya a asignar vuestro sistema operativo y la configuración que tengáis en el servidor Apache y PHP.

Información del uso de CPU

Para obtener la información del uso de la CPU en PHP usaremos la función getrusage(). Por el momento no esta disponible en plataformas con Windows.

print_r(getrusage());
/* devuelve el siguiente array de datos
Array
(
    [ru_oublock] => 0
    [ru_inblock] => 0
    [ru_msgsnd] => 2
    [ru_msgrcv] => 3
    [ru_maxrss] => 12692
    [ru_ixrss] => 764
    [ru_idrss] => 3864
    [ru_minflt] => 94
    [ru_majflt] => 0
    [ru_nsignals] => 1
    [ru_nvcsw] => 67
    [ru_nivcsw] => 4
    [ru_nswap] => 0
    [ru_utime.tv_usec] => 0
    [ru_utime.tv_sec] => 0
    [ru_stime.tv_usec] => 6269
    [ru_stime.tv_sec] => 0
)

*/

Explicación de cada valor:

  • ru_oublock: block output operations
  • ru_inblock: block input operations
  • ru_msgsnd: messages sent
  • ru_msgrcv: messages received
  • ru_maxrss: maximum resident set size
  • ru_ixrss: integral shared memory size
  • ru_idrss: integral unshared data size
  • ru_minflt: page reclaims
  • ru_majflt: page faults
  • ru_nsignals: signals received
  • ru_nvcsw: voluntary context switches
  • ru_nivcsw: involuntary context switches
  • ru_nswap: swaps
  • ru_utime.tv_usec: user time used (microseconds)
  • ru_utime.tv_sec: user time used (seconds)
  • ru_stime.tv_usec: system time used (microseconds)
  • ru_stime.tv_sec: system time used (seconds)

Para determinar cuanta energía ha consumido la CPU, habría que mirar a los valores de ‘user time’ y ‘system time’. Los segundos y las porciones de milisegundos son entregadas separadas por defecto. Se podría dividir el valor de milisegundos por 1 millón, y añadir el resultado a los segundos, para obtener el total de segundos como un número decimal.

Ver siguiente ejemplo:

// sleep de 3 segundos (non-busy)
sleep(3);

$data = getrusage();
echo "User time: ".
	($data['ru_utime.tv_sec'] +
	$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
	($data['ru_stime.tv_sec'] +
	$data['ru_stime.tv_usec'] / 1000000);

/* devuelve
User time: 0.011552
System time: 0
*/

A pesar de que el script duró 3 segundos para ejecutarse, el uso de la CPU es muy muy bajo. Durante la ejecución del sleep() el script no esta consumiendo recursos de CPU. Hay otras muchas tareas que se ejecutan en tiempo real pero que no consumen tiempo de CPU, como por ejemplo esperar para operaciones de disco. Por lo que, como se puede ver, el uso de la CPU y el tiempo de ejecución de un scipt no siempre coinciden.

Otro ejemplo:

// bucle de 10 millones de veces (busy, vamos a forzar un poquito)
for($i=0;$i<10000000;$i++) {

}

$data = getrusage();
echo "User time: ".
	($data['ru_utime.tv_sec'] +
	$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
	($data['ru_stime.tv_sec'] +
	$data['ru_stime.tv_usec'] / 1000000);

/* devuelve
User time: 1.424592
System time: 0.004204
*/

Esta operación ha llevado 1.4 segundos de tiempo de CPU, casi todas por parte de tiempo de usuario ya que no existían otras llamadas al sistema.

El tiempo del sistema (System time) es el total de tiempo de CPU gasta en ejecutar llamadas por el kernel en el nombre del programa. Veamos un ejemplo:

$start = microtime(true);
// seguimos llamando a microtime durante 3 segundos
while(microtime(true) - $start < 3) {

}

$data = getrusage();
echo "User time: ".
	($data['ru_utime.tv_sec'] +
	$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
	($data['ru_stime.tv_sec'] +
	$data['ru_stime.tv_usec'] / 1000000);

/* devuelve
User time: 1.088171
System time: 1.675315
*/

Ahora tenemos más uso del tiempo del sistema. Esto es porque el script llama a la función microtime() varias veces, que ejecuta una petición a través del sistema operativo para recoger la fecha.

Magic Constants

PHP provee de una herramienta super útil las: magic constants al español constantes mágicas (que suena un poco peor,no?).
Para obtener la linea actual donde estamos(__LINE__), la ruta del fichero (__FILE__), la ruta del directorio (__DIR__), el nombre de la función (__FUNCTION__), el nombre de la clase (__CLASS__), el nombre del método (__METHOD__) y namespace (__NAMESPACE__).

Este tipo de constantes son usada en desarrollo Open Source, como CakePHP, WordPress y otros códigos donde cada desarrollador los instala en diferentes rutas y el código debe ser capaz de determinar las rutas y cualquier otra información para poder funcionar correctamente

// Esto es relativo a la ruta del script cargado
// Este método puede dar problemas cuando se ejecutan scripts desde diferentes rutas
require_once('config/database.php');

// Esto siempre es relativo a la ruta del fichero
// no importa desde donde se esté ejecutando el include
require_once(dirname(__FILE__) . '/config/database.php');

Usar __LINE__ hace que el debuging o la localización de errores sea mucho más fácil. Puedes obtener el número de linea que esta fallando.

// cualquier código
// ...
my_debug("some debug message", __LINE__);
/* devuelve
Line 4: some debug message
*/

// otro código diferente
// ...
my_debug("another debug message", __LINE__);
/* prints
Line 11: another debug message
*/

function my_debug($msg, $line) {
	echo "Line $line: $msgn";
}

También se podría hablar mucho sobre las constantes: __FUNCTION__, __CLASS__ y __METHOD__ las cuales pueden ayudar muchísimo al trabajo con objetos y con la creación y definición de patrones de diseño en el código, pero el uso de éstas constantes para trabajar con objetos podría ser motivo de un artículo tan sólo para esto. En la documentación de php http://php.net/manual/en/language.constants.predefined.php hay otros consejos y ejemplos.

Generar IDs únicos

There may be situations where you need to generate a unique string. I have seen many people use the md5() function for this, even though it’s not exactly meant for this purpose:

En muchas situaciones vamos a necesitar generar identificadores o cadenas únicas. Confieso que yo suelo hacer esto: md5(time()) para generar string únicos, aunque puede que no sea 100% optimo. PHP propone la siguiente función específica para llevar a cabo esta tarea, uniqid().


// genera una cadena única
echo uniqid();
/* devuelve
4bd67c947233e
*/

El inicio de la cadena suele ser similar entre los diferentes identificadores que vamos generando, ya que el string generado está relacionando con la fecha del servidor, es decir con la función time(). Esto tiene una ventaja ya que todos los ids generados van en orden alfabético y se podrían ordenar.

Puedes enviar como primer parámetro en la función un prefijo y puede poner a true el segundo valor para aumentar la entropía, (usando el generador de congruencia lineal combinado) al final del valor de retorno, lo que aumenta la probabilidad de que el resultado será único. Por defecto devuelve una cadena de 13 caracteres, si se activa la entropía devuelve una cadena de 23 caracteres.

// con prefijo
echo uniqid('foo_');
/* devuelve
foo_4bd67d6cd8b8f
*/

// con más entropía
echo uniqid('',true);
/* devuelve
4bd67d6cd8b926.12135106
*/

// ambos
echo uniqid('bar_',true);
/* devuelve
bar_4bd67da367b650.43684647
*/

Esta función genera una cadena más corta que md5(), con lo que nos ayudará a ahorrar algo de espacio.

Serialización en PHP

La serialización básicamente es el formateo de arrays u objetos para convertirlos en un string. PHP ya tiene funciones que hacen esta tarea.

Hay 2 métodos para serializar variables, serialize() y unserialize():

// datos en un array
$myvar = array(
	'hello',
	42,
	array(1,'two'),
	'apple'
);

// convertimos a string
$string = serialize($myvar);

echo $string;
/* devuelve
a:4:{i:0;s:5:"hello";i:1;i:42;i:2;a:2:{i:0;i:1;i:1;s:3:"two";}i:3;s:5:"apple";}
*/

// incluso puedes volver al estado original
$newvar = unserialize($string);

print_r($newvar);
/* devuelve
Array
(
    [0] => hello
    [1] => 42
    [2] => Array
        (
            [0] => 1
            [1] => two
        )

    [3] => apple
)
*/

This was the native PHP serialization method. However, since JSON has become so popular in recent years, they decided to add support for it in PHP 5.2. Now you can use the json_encode() and json_decode() functions as well:

Estos son los métodos nativos de PHP para serializar. Sin embargo desde que JSON se volvió más popular, PHP sacó las funciones de json_encode() y json_decode en la versión 5.2.

Si tienes una versión de PHP inferior a 5.2 y llamas a las funciones de json_decode() o json_encode(), te aparecerá un error similar a este PHP Fatal error: Call to undefined function: json_encode(). Como he dicho, esta mejora aparece en la versión 5.2, para más información leer el siguiente artículo donde ya lo comentaba hace unos años http://www.pedroventura.com/php/php-fatal-error-call-to-undefined-function-json_encode/

// un array
$myvar = array(
	'hello',
	42,
	array(1,'two'),
	'apple'
);

// convertimos a string
$string = json_encode($myvar);

echo $string;
/* devuelve
["hello",42,[1,"two"],"apple"]
*/

// podemos volver al array original
$newvar = json_decode($string);

print_r($newvar);
/* devuelve
Array
(
    [0] => hello
    [1] => 42
    [2] => Array
        (
            [0] => 1
            [1] => two
        )

    [3] => apple
)
*/

Comprimir cadenas en PHP

Cuando hablamos de compresión, casi siempre nos referimos a ficheros, tales como los archivos ZIP. Pero es posible comprimir largas cadenas en PHP sin involucrar la creación de ningún archivo.

Para esta tarea usaremos las funciones gzcompress() y gzuncompress()

$string =
"Lorem ipsum dolor sit amet, consectetur
adipiscing elit. Nunc ut elit id mi ultricies
adipiscing. Nulla facilisi. Praesent pulvinar,
sapien vel feugiat vestibulum, nulla dui pretium orci,
non ultricies elit lacus quis ante. Lorem ipsum dolor
sit amet, consectetur adipiscing elit. Aliquam
pretium ullamcorper urna quis iaculis. Etiam ac massa
sed turpis tempor luctus. Curabitur sed nibh eu elit
mollis congue. Praesent ipsum diam, consectetur vitae
ornare a, aliquam a nunc. In id magna pellentesque
tellus posuere adipiscing. Sed non mi metus, at lacinia
augue. Sed magna nisi, ornare in mollis in, mollis
sed nunc. Etiam at justo in leo congue mollis.
Nullam in neque eget metus hendrerit scelerisque
eu non enim. Ut malesuada lacus eu nulla bibendum
id euismod urna sodales. ";

$compressed = gzcompress($string);

echo "Original size: ". strlen($string)."n";
/* prints
Original size: 800
*/



echo "Compressed size: ". strlen($compressed)."n";
/* prints
Compressed size: 418
*/

// getting it back
$original = gzuncompress($compressed);

Con esta técnica somos capaces de reducir al 50% el tamaño. También están las funciones gzencode() y gzdecode() que obtienen resultados similares pero con diferentes algoritmos de compresión

Lecturas recomendadas sobre compresión de archivos:

Registrar función de apagado (shutdown)

Hay una función llamada register_shutdown_function() que te permite ejecutar código justo después de que termine la ejecución del script.

Imagina que quieres capturas datos para estadísticas al final de la ejecución de un script, como por ejemplo cuanto tiempo tardó en ejecutarse.

// obtenemos el tiempo inicial
$start_time = microtime(true);

// aquí todo el código y la lógica
// ...

// mostramos cuanto tiempo tardó el script
echo "execution took: ".
		(microtime(true) - $start_time).
		" seconds.";

En este ejemplo parece un poco simple y sin mucho sentido, es un código al inicio y otro al final y no parece que esta función se pueda estar ejecutando al final del script, ya que está al final. Pero hay que tener en cuenta, de que si se añade un exit(), el código devuelve un fatal error o incluso si el usuario detiene la ejecución del script con el botón de parar del navegador esta función siempre se va seguir ejecutando a pesar de todo.

Conclusión

Que te ha parecido? has aprendido algunas funciones nuevas? Yo por lo menos he aprendido unas cuantas y he refrescado otras que hacía mucho tiempo no había utilizado.

De todas maneras si conoces de otras funciones que sean desconocidas pero útiles no dudes en comentarlas, con tus comentarios aportas tu experiencia y opinión al resto de lectores

Fuente: http://net.tutsplus.com/tutorials/php/9-useful-php-functions-and-features-you-need-to-know/

Tags de búsquedas:

funciones utiles de php,obtener argumentos con php,serialize en php obtener datos,usados pero no tanto,pasar variable despues de funcion php,php 5 4 include detiene script,php buscar fichero,php buscar fichero glob,php crear archivo en tiempo de ejecución,php crear archivo zip despues guardarlo en disco,php detectar patrones leyendo html,php ejecutar funcion al final de la ejecucion,php extraer datos de un txt,php funciones de busqueda en memoria,php funciones utiles

Noticias relacionadas »

6 comentarios en Funciones en PHP no tan usadas pero útiles

  1. Jaime
    / Responder

    Muy interesante el artículo.

    Gracias por el aporte,

    Saludos!

  2. max
    / Responder

    compadre estubo muy pero muy bueno el post… te agradezco esos tips… a veces me la paso leyendo los manueles pero asi con este tipo de ejemplos uno aprende muy bien … gracias

  3. JOSE FERNANDEZ
    / Responder

    excelente, y valla que si son utiles…

  4. Antonio
    / Responder

    Una web muy útil y amena.
    Aquí teneis un seguidor más…

  5. miguel
    / Responder

    Como dices, muy útiles.
    Saludos.

  6. Alberto
    / Responder

    Muy buen aporte amigo, esto va a ayudar a muchos novatos a salir adelante!

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Invertir en criptomonedas: »

 

Cómo comprar bitcoin

Invertir y comprar Bitcoin y otras altcoins es más fácil de lo que crees.

1) Si sólo quieres comprar Bitcoin, Ethereum o Litecoin como inversión, tu opción es Coinbase

2) Si quieres probar con otras criptomonedas tu opción es Binance

3) Cualquier duda escríbeme con total libertad al formulario de contacto para resolver dudas: https://www.pedroventura.com/contacto/

¡Comparte este artículo! »

  • Zein (2 días)
    EXELENTEE!!! MIL PUNTOS PARA TI! si me funcionó a la…
  • señales cryptowhale (3 días)
    https://t.me/SignalsWins
  • carlos hernandez (1 semana)
    Hola, hay alguna funcion k sirva para saber el correo…
  • steven (3 semanas)
    tengo un problema me sale este error cuando pongo data:…
  • lewis rod (4 semanas)
    https://t.me/joinchat/Hs_yUFG_xDVJ-PS3cWEYAw este es el enlace me equivoque.
  • lewis rod (4 semanas)
    https://t.me/joinchat/Hs_yUBDhw2Uk7D3D835GJQ grupo de telegram latino sudamericano peru, colombia, ecuador, chile,…

Suscríbete al newsletter »

Proporciona tu correo electrónico a continuación y recibe las últimas noticias! Funciona con Feedburner de Google

Archivo »

Leer entrada anterior
Funciones MySQL para convertir timestamp a fecha

En el siguiente artículo comentaré cómo pasar la representación de una fecha en timestamp de unix a formato de tipo...

Cerrar