Funciones para optimizar scripts PHP

Funciones para optimizar scripts PHP

 

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 nuestrosoftware, 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ónmemory_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 CakePHPWordPress 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 phphttp://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 funcionesgzencode() 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

Comparte este artículo