Ads 468x60px

Perfil

viernes, 10 de mayo de 2013

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:
1// función con 2 argumentos opcionales
2function foo($arg1 = '', $arg2 = '') {
3 
4    echo "arg1: $arg1n";
5    echo "arg2: $arg2n";
6 
7}
8 
9 
10foo('hello','world');
11/* muestra
12arg1: hello
13arg2: world
14*/
15 
16foo();
17/* Muestra
18arg1:
19arg2:
20*/
Ahora, vamos a construir una función que acepte cualquier número de argumentos. Esta vez vamos a utilizar func_get_args():
1// si, la lista de argumentos va vacía
2function foo() {
3 
4    // devuelve un array con todos los argumentos que se han pasado
5    $args = func_get_args();
6 
7    foreach ($args as $k => $v) {
8        echo "arg".($k+1).": $vn";
9    }
10 
11}
12 
13foo();
14/* no muestra nada */
15 
16foo('hello');
17/* muestra
18arg1: hello
19*/
20 
21foo('hello', 'world', 'again');
22/* muestra
23arg1: hello
24arg2: world
25arg3: again
26*/

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.
1// buscados todos los archivos con extensión .php, podría ser cualquier otra extensión.
2$files = glob('*.php');
3 
4print_r($files);
5/* los datos de salida serán algo similar a esto
6Array
7(
8    [0] => phptest.php
9    [1] => pi.php
10    [2] => post_output.php
11    [3] => test.php
12)
13*/
También se pueden extraer múltiples tipos de ficheros de la siguiente manera:
1// sacamos todos los archivos con extensión .php y .txt
2$files = glob('*.{php,txt}', GLOB_BRACE);
3 
4print_r($files);
5/* los datos de salida se parecerán a los siguientes
6Array
7(
8    [0] => phptest.php
9    [1] => pi.php
10    [2] => post_output.php
11    [3] => test.php
12    [4] => log.txt
13    [5] => test.txt
14)
15*/
NOTA: Los archivos se pueden devolver con su ruta, dependiendo de la búsqueda que se haga
1$files = glob('../images/a*.jpg');
2 
3print_r($files);
4/* datos de salida
5Array
6(
7    [0] => ../images/apple.jpg
8    [1] => ../images/art.jpg
9)
10*/
Si quieres obtener la ruta completa de cada archivo, tendrías que llamar a la función realpath() en los valores retornados.
1$files = glob('../images/a*.jpg');
2 
3// aplico la función a cada elemento del array
4$files = array_map('realpath',$files);
5 
6print_r($files);
7/* datos de salida
8Array
9(
10    [0] => C:wampwwwimagesapple.jpg
11    [1] => C:wampwwwimagesart.jpg
12)
13*/

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.
1echo "Bytes iniciales: ".memory_get_usage()."n";
2/* mostrará por ejemploo
3Bytes iniciales: 361400
4*/
5 
6// vamos a forzar el uso de memoria
7for ($i = 0; $i < 100000; $i++) {
8    $array []= md5($i);
9}
10 
11// vamos a eliminar la mitad del array
12for ($i = 0; $i < 100000; $i++) {
13    unset($array[$i]);
14}
15 
16echo "Final: ".memory_get_usage()." bytes n";
17/* imprime
18Final: 885912 bytes
19*/
20 
21echo "Peak: ".memory_get_peak_usage()." bytes n";
22/* imprime
23Peak: 13687072 bytes
24*/
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.
1print_r(getrusage());
2/* devuelve el siguiente array de datos
3Array
4(
5    [ru_oublock] => 0
6    [ru_inblock] => 0
7    [ru_msgsnd] => 2
8    [ru_msgrcv] => 3
9    [ru_maxrss] => 12692
10    [ru_ixrss] => 764
11    [ru_idrss] => 3864
12    [ru_minflt] => 94
13    [ru_majflt] => 0
14    [ru_nsignals] => 1
15    [ru_nvcsw] => 67
16    [ru_nivcsw] => 4
17    [ru_nswap] => 0
18    [ru_utime.tv_usec] => 0
19    [ru_utime.tv_sec] => 0
20    [ru_stime.tv_usec] => 6269
21    [ru_stime.tv_sec] => 0
22)
23 
24*/
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:
1// sleep de 3 segundos (non-busy)
2sleep(3);
3 
4$data = getrusage();
5echo "User time: ".
6    ($data['ru_utime.tv_sec'] +
7    $data['ru_utime.tv_usec'] / 1000000);
8echo "System time: ".
9    ($data['ru_stime.tv_sec'] +
10    $data['ru_stime.tv_usec'] / 1000000);
11 
12/* devuelve
13User time: 0.011552
14System time: 0
15*/
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:
1// bucle de 10 millones de veces (busy, vamos a forzar un poquito)
2for($i=0;$i<10000000;$i++) {
3 
4}
5 
6$data = getrusage();
7echo "User time: ".
8    ($data['ru_utime.tv_sec'] +
9    $data['ru_utime.tv_usec'] / 1000000);
10echo "System time: ".
11    ($data['ru_stime.tv_sec'] +
12    $data['ru_stime.tv_usec'] / 1000000);
13 
14/* devuelve
15User time: 1.424592
16System time: 0.004204
17*/
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:
1$start = microtime(true);
2// seguimos llamando a microtime durante 3 segundos
3while(microtime(true) - $start < 3) {
4 
5}
6 
7$data = getrusage();
8echo "User time: ".
9    ($data['ru_utime.tv_sec'] +
10    $data['ru_utime.tv_usec'] / 1000000);
11echo "System time: ".
12    ($data['ru_stime.tv_sec'] +
13    $data['ru_stime.tv_usec'] / 1000000);
14 
15/* devuelve
16User time: 1.088171
17System time: 1.675315
18*/
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
1// Esto es relativo a la ruta del script cargado
2// Este método puede dar problemas cuando se ejecutan scripts desde diferentes rutas
3require_once('config/database.php');
4 
5// Esto siempre es relativo a la ruta del fichero
6// no importa desde donde se esté ejecutando el include
7require_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.
1// cualquier código
2// ...
3my_debug("some debug message", __LINE__);
4/* devuelve
5Line 4: some debug message
6*/
7 
8// otro código diferente
9// ...
10my_debug("another debug message", __LINE__);
11/* prints
12Line 11: another debug message
13*/
14 
15function my_debug($msg, $line) {
16    echo "Line $line: $msgn";
17}
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().
1// genera una cadena única
2echo uniqid();
3/* devuelve
44bd67c947233e
5*/
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.
1// con prefijo
2echo uniqid('foo_');
3/* devuelve
4foo_4bd67d6cd8b8f
5*/
6 
7// con más entropía
8echo uniqid('',true);
9/* devuelve
104bd67d6cd8b926.12135106
11*/
12 
13// ambos
14echo uniqid('bar_',true);
15/* devuelve
16bar_4bd67da367b650.43684647
17*/
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():
1// datos en un array
2$myvar = array(
3    'hello',
4    42,
5    array(1,'two'),
6    'apple'
7);
8 
9// convertimos a string
10$string = serialize($myvar);
11 
12echo $string;
13/* devuelve
14a: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";}
15*/
16 
17// incluso puedes volver al estado original
18$newvar = unserialize($string);
19 
20print_r($newvar);
21/* devuelve
22Array
23(
24    [0] => hello
25    [1] => 42
26    [2] => Array
27        (
28            [0] => 1
29            [1] => two
30        )
31 
32    [3] => apple
33)
34*/
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/
1// un array
2$myvar = array(
3    'hello',
4    42,
5    array(1,'two'),
6    'apple'
7);
8 
9// convertimos a string
10$string = json_encode($myvar);
11 
12echo $string;
13/* devuelve
14["hello",42,[1,"two"],"apple"]
15*/
16 
17// podemos volver al array original
18$newvar = json_decode($string);
19 
20print_r($newvar);
21/* devuelve
22Array
23(
24    [0] => hello
25    [1] => 42
26    [2] => Array
27        (
28            [0] => 1
29            [1] => two
30        )
31 
32    [3] => apple
33)
34*/

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()
1$string =
2"Lorem ipsum dolor sit amet, consectetur
3adipiscing elit. Nunc ut elit id mi ultricies
4adipiscing. Nulla facilisi. Praesent pulvinar,
5sapien vel feugiat vestibulum, nulla dui pretium orci,
6non ultricies elit lacus quis ante. Lorem ipsum dolor
7sit amet, consectetur adipiscing elit. Aliquam
8pretium ullamcorper urna quis iaculis. Etiam ac massa
9sed turpis tempor luctus. Curabitur sed nibh eu elit
10mollis congue. Praesent ipsum diam, consectetur vitae
11ornare a, aliquam a nunc. In id magna pellentesque
12tellus posuere adipiscing. Sed non mi metus, at lacinia
13augue. Sed magna nisi, ornare in mollis in, mollis
14sed nunc. Etiam at justo in leo congue mollis.
15Nullam in neque eget metus hendrerit scelerisque
16eu non enim. Ut malesuada lacus eu nulla bibendum
17id euismod urna sodales. ";
18 
19$compressed = gzcompress($string);
20 
21echo "Original size: ". strlen($string)."n";
22/* prints
23Original size: 800
24*/
25 
26 
27 
28echo "Compressed size: ". strlen($compressed)."n";
29/* prints
30Compressed size: 418
31*/
32 
33// getting it back
34$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.
1// obtenemos el tiempo inicial
2$start_time = microtime(true);
3 
4// aquí todo el código y la lógica
5// ...
6 
7// mostramos cuanto tiempo tardó el script
8echo "execution took: ".
9        (microtime(true) - $start_time).
10        " 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/