9 Funciones y Características Útiles en PHP que Usted Necesita Saber

Spanish (Español) translation by Jorge Montoya (you can also view the original English article)

Dos veces por mes, volvemos a visitar algunas de las publicaciones favoritas de nuestros lectores a lo largo de toda la historia de Nettuts+.

Incluso después de utilizar PHP por años, nos tropezamos con funciones y características que no conocíamos. Algunas de estas pueden ser muy útiles, sin embargo subutilizadas. Con eso en mente, he compilado una lista de nueve funciones y características increíbles de PHP con las que usted debería familiarizarse.

1. Funciones con un Número Arbitrario de Argumentos

Ya puede que ya sepa que PHP le permite definir funciones con argumentos opcionales. Pero también existe un método para permitir un número completamente arbitrario de argumentos de función.

En primer lugar, aquí hay un ejemplo solo con argumentos opcionales:


// function with 2 optional arguments
function foo($arg1 = '', $arg2 = '') {

  echo "arg1: $arg1\n";
	echo "arg2: $arg2\n";

}


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

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

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


// yes, the argument list can be empty
function foo() {

	// returns an array of all passed arguments
	$args = func_get_args();

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

}

foo();
/* prints nothing */

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

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

2. Uso de Glob() para Encontrar Archivos

Muchas funciones de PHP tienen nombres largos y descriptivos. Sin embargo, puede ser difícil saber qué hace una función llamada glob() a menos que ya esté familiarizado con ese término de otra parte.

Piense en ello como una versión más capaz de la función scandir(). Puede permitirte buscar archivos usando patrones.


// get all php files
$files = glob('*.php');

print_r($files);
/* output looks like:
Array
(
    [0] => phptest.php
    [1] => pi.php
    [2] => post_output.php
    [3] => test.php
)
*/

Puede obtener varios tipos de archivo como este:


// get all php files AND txt files
$files = glob('*.{php,txt}', GLOB_BRACE);

print_r($files);
/* output looks like:
Array
(
    [0] => phptest.php
    [1] => pi.php
    [2] => post_output.php
    [3] => test.php
    [4] => log.txt
    [5] => test.txt
)
*/

Tenga en cuenta que los archivos pueden ser devueltos con una ruta, dependiendo de su consulta:


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

print_r($files);
/* output looks like:
Array
(
    [0] => ../images/apple.jpg
    [1] => ../images/art.jpg
)
*/

Si desea obtener la ruta completa a cada archivo, sólo puede llamar a la función realpath() en los valores devueltos:


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

// applies the function to each array element
$files = array_map('realpath',$files);

print_r($files);
/* output looks like:
Array
(
    [0] => C:\wamp\www\images\apple.jpg
    [1] => C:\wamp\www\images\art.jpg
)
*/

3. Información Sobre el Uso de la Memoria

Observando el uso de la memoria de sus scripts, puede optimizar mejor su código.

PHP tiene un recolector de basura y un administrador de memoria bastante complejo. La cantidad de memoria utilizada por el script. puede subir y bajar durante la ejecución de un script. Para obtener el uso actual de la memoria, podemos usar la función memory_get_usage(), y para obtener la mayor cantidad de memoria utilizada en cualquier punto, podemos usar la función memory_get_peak_usage().


echo "Initial: ".memory_get_usage()." bytes \n";
/* prints
Initial: 361400 bytes
*/

// let's use up some memory
for ($i = 0; $i < 100000; $i++) {
	$array []= md5($i);
}

// let's remove half of the array
for ($i = 0; $i < 100000; $i++) {
	unset($array[$i]);
}

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

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

4. Información de Uso de la CPU

Para ello, vamos a utilizar la función getrusage(). Tenga en cuenta que esto no está disponible en plataformas Windows.


print_r(getrusage());
/* prints
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
)

*/

Eso puede parecer un poco críptico a menos que ya tenga un conocimientos de administración de sistema. Aquí está la explicación de cada valor (no es necesario memorizarlos):

ru_oublock: bloquear operaciones de salida
ru_inblock: bloquear operaciones de entrada
ru_msgsnd: mensajes enviados
ru_msgrcv: mensajes recibidos
ru_maxrss: tamaño máximo del conjunto de residentes
ru_ixrss: tamaño de memoria compartida integral
ru_idrss: tamaño de datos sin compartir
ru_minflt: reclamaciones de página
ru_majflt: fallos de página
ru_nsignals: señales recibidas
ru_nvcsw: cambios de contexto voluntarios
ru_nivcsw: cambios involuntarios de contexto
ru_nswap: intercambios
ru_utime.tv_usec: tiempo de usuario utilizado (microsegundos)
ru_utime.tv_sec: tiempo de uso del usuario (segundos)
ru_stime.tv_usec: tiempo del sistema utilizado (microsegundos)
ru_stime.tv_sec: tiempo del sistema utilizado (segundos)

Para ver cuánta potencia de CPU consumió el script, debemos mirar los valores de 'tiempo de usuario' y 'tiempo de sistema'. Las porciones de segundos y microsegundos se proporcionan por separado por defecto. Puede dividir el valor de microsegundos en 1 millón y agregarlo al valor de segundos, para obtener el total de segundos como un número decimal.

Veamos un ejemplo:


// sleep for 3 seconds (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);

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

A pesar de que el script tomó unos 3 segundos para ejecutarse, el uso de la CPU fue muy, muy bajo. Porque durante la operación de suspensión, el script realmente no consume recursos de CPU. Hay muchas otras tareas que pueden tomar tiempo real, pero no puede utilizar el tiempo de CPU, como esperar operaciones de disco. Por lo tanto, como puede ver, el uso de la CPU y la duración real del tiempo de ejecución no siempre son los mismos.

Aquí hay otro ejemplo:


// loop 10 million times (busy)
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);

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

Eso llevó alrededor de 1,4 segundos de tiempo de la CPU, casi todo el tiempo del usuario, ya que no había llamadas del sistema.

El Tiempo del Sistema es la cantidad de tiempo que la CPU pasa realizando llamadas del sistema para el kernel en nombre del programa. Aquí hay un ejemplo de eso:


$start = microtime(true);
// keep calling microtime for about 3 seconds
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);

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

Ahora tenemos un bastante tiempo de uso del sistema. Esto se debe a que el script llama a la función microtime() muchas veces, lo que realiza una solicitud a través del sistema operativo para obtener la hora.

También puede notar que los números no suman hasta 3 segundos. Esto es porque probablemente hay otros procesos en el servidor, así, y el script no estaba usando 100% de la CPU durante toda la duración de los 3 segundos.

5. Constantes Mágicas

PHP proporciona constantes mágicas útiles para buscar el número de línea actual (__LINE__), la ruta del archivo (__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 el espacio de nombre (__NAMESPACE__).

No vamos a cubrir cada uno de estos en este artículo, pero voy a mostrar algunos casos de uso.

Al incluir otros scripts, es una buena idea utilizar la constante __FILE__ (o también __DIR__, a partir de PHP 5.3):


// this is relative to the loaded script's path
// it may cause problems when running scripts from different directories
require_once('config/database.php');

// this is always relative to this file's path
// no matter where it was included from
require_once(dirname(__FILE__) . '/config/database.php');

El uso de __LINE__ facilita la depuración. Puede rastrear los números de línea:


// some code
// ...
my_debug("some debug message", __LINE__);
/* prints
Line 4: some debug message
*/

// some more code
// ...
my_debug("another debug message", __LINE__);
/* prints
Line 11: another debug message
*/

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

6. Generación de IDs Únicos

Puede haber situaciones en las que necesite generar una cadena única. He visto a muchas personas usar la función md5() para esto, aunque no es exactamente para este propósito:

1
2	// generate unique string
3	echo md5(time() . mt_rand(1,1000000));

En realidad, existe una función PHP llamada uniqid() que está destinada a ser utilizada para esto.


// generate unique string
echo uniqid();
/* prints
4bd67c947233e
*/

// generate another unique string
echo uniqid();
/* prints
4bd67c9472340
*/

Puede notar que aunque las cadenas son únicas, parecen similares por los primeros caracteres. Esto se debe a que la cadena generada está relacionada con la hora del servidor. Esto realmente tiene un buen efecto secundario, ya que cada nuevo ID generado viene más tarde en orden alfabético, por lo que se pueden ordenar.

Para reducir las posibilidades de obtener un duplicado, puede pasar un prefijo o el segundo parámetro para aumentar la entropía:


// with prefix
echo uniqid('foo_');
/* prints
foo_4bd67d6cd8b8f
*/

// with more entropy
echo uniqid('',true);
/* prints
4bd67d6cd8b926.12135106
*/

// both
echo uniqid('bar_',true);
/* prints
bar_4bd67da367b650.43684647
*/

Esta función generará cadenas más cortas que md5(), lo que también le ahorrará algo de espacio.

7. Serialización

¿Alguna vez ha necesitado almacenar una variable compleja en una base de datos o un archivo de texto? No tiene que encontrar una solución elegante para convertir sus arrays u objetos en cadenas formateadas, ya que PHP ya tiene funciones para este propósito.

Hay dos métodos populares de serialización de variables. He aquí un ejemplo que utiliza serialize() y unserialize():


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

// convert to a string
$string = serialize($myvar);

echo $string;
/* prints
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";}
*/

// you can reproduce the original variable
$newvar = unserialize($string);

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

    [3] => apple
)
*/

Este fue el método de serialización PHP nativo. Sin embargo, desde que JSON se ha vuelto tan popular en los últimos años, decidieron añadir compatibilidad con PHP 5.2. Ahora también puede usar las funciones json_encode() y json_decode():


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

// convert to a string
$string = json_encode($myvar);

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

// you can reproduce the original variable
$newvar = json_decode($string);

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

    [3] => apple
)
*/

Es más compacto, y lo mejor de todo, compatible con javascript y muchos otros lenguajes. Sin embargo, para objetos complejos, se puede perder alguna información.

8. Compresión de Cadenas de Texto

Al hablar de compresión, por lo general pensamos en archivos, como archivos ZIP. Es posible comprimir cadenas largas en PHP, sin involucrar archivos comprimidos.

En el siguiente ejemplo vamos a utilizar 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);

Pudimos alcanzar casi el 50% de reducción de tamaño. También las funciones gzencode() y gzdecode() tienen resultados similares, utilizando un algoritmo de compresión diferente.

9. Función de Cierre de Registro

Hay una función llamada register_shutdown_function(), que le permitirá ejecutar algún código justo antes de que el script termine de ejecutarse.

Imagine que desea capturar algunas estadísticas de referencia al final de la ejecución del script, como cuánto tardó en ejecutarse:


// capture the start time
$start_time = microtime(true);

// do some stuff
// ...

// display how long the script took
echo "execution took: ".
		(microtime(true) - $start_time).
		" seconds.";

Al principio esto puede parecer trivial. Sólo agregue el código al final de la secuencia de comandos y se ejecuta antes de que finalice. Sin embargo, si alguna vez llama a la función exit(), ese código nunca se ejecutará. Además, si hay un error fatal, o si el script es terminado por el usuario (presionando el botón Detener en el navegador), de nuevo puede no ejecutarse.

Cuando utiliza register_shutdown_function(), su código se ejecutará sin importar por qué el script ha dejado de ejecutarse:


$start_time = microtime(true);

register_shutdown_function('my_shutdown');

// do some stuff
// ...


function my_shutdown() {
	global $start_time;

	echo "execution took: ".
			(microtime(true) - $start_time).
			" seconds.";
}

Conclusión

¿Está al tanto de otras funciones de PHP que no son ampliamente conocidas pero que pueden ser muy útiles? Por favor, comparta con nosotros en los comentarios. ¡Y gracias por leer!