aNieto2K Desarrollo web, Wordpress, y alguna cosilla más

Una de esas funciones que nos ayudan a hacer más fácil nuestro trabajo con WordPress es rewind_posts(), y aunque su uso no es muy común, en alguna situación podemos alegrarnos de conocerla.

rewind_posts()

<?php
 query_posts('....');
 while (have_posts()) : the_post();
 ...
 endwhile;

 // Reiniciamos los posts
 rewind_posts();

 // Nueva query_posts()
 query_posts('....');
 while (have_posts()) : the_post();
 ...
 endwhile;
 ?>

Está función, disponible como método de WP_Query, es la función encargada de reiniciar el Loop de WordPress para poder usarlo complementamente vacio despues de llamar a esta función. Ideal para el uso de varios Loops en una misma página.

Los blogs y las prisas dieron lugar a una tendencia llamada microblogging, que básicamente se trata de generar «blogs» especializados en pequeños posts. Similar a lo que hacemos con Twitter o Tumblr, estas aplicaciones nos permiten compartir con Internet nuestras pequeñas ideas, enlaces encontrados,….

Implementar un sistema de estos es muy sencillo, y con estas herramientas aún es más sencillo 😀

• StatusNet: Desarrollado en PHP + MySQL
• Yonkly: Desarrollado en ASP.Net
• JaikuEngine: Desarrollado en Python
• Floopo: Desarrollado en PHP + MySQL
• Jisko: Desarrollado en PHP + MySQL y compatible con dispositivos móviles por defecto.
• PageCookery: Desarrollado en PHP + MySQL con un interface enriquecido por Ajax.
• EchoWaves: Desarrollado en Ruby and Rails.
• P2 WordPress Theme: Theme para WordPress que convierte tu WordPress en un microblog.
• Motion: Desarrollado en Python sobre Django.
• Blurt.it: Desarrollado en PHP + MySQL.

Isra, nos muestra una librería en PHP que ha desarrollado para ayudarnos a trabajar con CSS de una forma muy cómoda y profesional.

$styles = new CssDispatcher; 

$styles->add(new Css('ie-hacks.css.php'));
$styles->add(new Css('general.css.php')); 

$styles->render();

CssDispatcher, se encarga de procesar los ficheros .css permitiendo así que podamos incluir código PHP en nuestras hojas de estilos, además de unir y comprimir todas las hojas de estilo que necesitemos en nuestro proyecto.

$styles = new CssDispatcher; 

// Este CSS solo se enviará cuando sea Internet Explorer 6
$styles->add(new Css('ie-hacks.css.php', Css::UA_IE6));
$styles->add(new Css('general.css.php')); 

$styles->render();

Además, nos permite condicionar nuestro CSS dependiendo del navegador que nos visita. De esta forma, podemos cargar un fichero, o no, dependiendo si el navegador que nos visita es el especificado previamente.

CSScaffold es un framework CSS con el que podemos extender las posibilidades de nuestros CSS desde PHP. Básicamente se trata de un script PHP que recoge los ficheros .CSS a tratar y mediante una nomenclatura (que veremos más adelante) nos genera unos ficheros CSS que cualquier navegador podrá interpretar.

(Ver Imagen)

// Ejemplo de uso:
<link href="/scaffold/index.php?request=/css/master.css" />

Continua —>

Hace ya más de 3 años vimos una función para recoger parámetros pasados por GET mediante Javascript. Esta implementación pasaba por parsear la URL actual y obtener de ahí los parámetros. Pues en codeNothing? han implementado una versión para los amantes de php.

;(function(window){
var
 $_GET = window.$_GET = {},
 $_VAN = window.$_VAN = {},
 location = window.location,
 search = location.search,
 href = location.href, 

 index = search.indexOf('?') != -1 ? search.indexOf('?') + 1 : 0,
 get = search.substr(index).split('&'),
 vanity = href.replace(/^https?:\/\/(.*?)\//i, '').replace(/\?.*$/i, '').split('/'); 

 for (var i in get){
 var split = get[i].split('=');
 $_GET[split[0]] = split[1]||null;
 }
 for (var i in vanity)
 $_VAN[i] = vanity[i]||null;
})(window);
// Modo de uso

var param = $_GET["param"];
alert("Parámetro: " + param);

Como podemos ver, esta función  nos permite añadir al objeto window la variable $_GET y usarla exactamente igual que en PHP.

Hace unas semanas tuve que implementar una Class para cachear elementos de mi PHP en ficheros estáticos. Inicialmente usé un sistema similar al que había usado siempre basado en la función filemtime() que me devolvía la fecha de modificación del archivo estático y la contrastaba con la actual, si el resultado era mayor a un número de segundos especificado volvía a generar el fichero estático.

Código filemtime()

class Cache {
 function fileName($key){
 return 'cache/'.md5($key);
 }

 function put($key, $datos){
 $f = fopen($this->fileName($key), 'w');
 if (!$f) die('No se puede leer el fichero de caché');

 $data = serialize($data);

 if (fwrite($f,$data)===false) {
 die('No se puede escribir el fichero de caché');
 }
 fclose($f);
 }

 function get($key){
 $filename = $this->fileName($key);
 if (!file_exists($filename) || !is_readable($filename)) return false;
 if ((filemtime($filename) + 3600) < time()) {
 return file_get_contents($filename);
 }
 return false;
 }
}

Esta versión, me permite cachear en fichero cualquier contenido que yo le indique mediante put(). Veamos un ejemplo.

$cache = new Cache();
if (!$data = $cache->get('misdatos')) {
 ....
 $cache->put('misdatos', $misdatos);
}

Problemas

Tras unas horas usándolo me encontré con un problema, la poca flexibilidad de este sistema. Necesitaba que ciertos datos, se cachearan una hora y otros lo hicieran 24. De esta forma me era dificil montar un sistema basado en filemtime() que me permitiera indicar una caché para tiempos diferentes.

Las soluciones pasaba por comprobar el tipo de contenido y dependiendo de que fuera tomar un tiempo u otro, o crear métodos específicos para cachear por tiempos (put60(), put24(),…). Ninguna solución me parecía elegante.

Serialize()

Entonce recordé un artículo de hace ya unos años en los que mediante el uso de serialize() permitía hacer lo que estaba buscando.

serialize() es una función de PHP que permite convertir un objeto que puede ser fácilmente almacenable. Algo que me venía ideal para hacer que mi caché de ficheros estática fuera más flexible.

Código serialize()

>class Cache {
 var $cacheDir;

 function __construct($cacheDir = './'){
 $this->cacheDir = $cacheDir;
 }

 // Indicamos el directorio donde queremos alojar los ficheros de caché
 function put( $key , $data ,$time = 600) {

 $h = fopen( $this->getFileName( $key ) , 'w' );
 if (!$h) throw new Error('No se puede leer el fichero de caché');

 $data = serialize( array( time() + $time , $data ) );

 if ( fwrite( $h , $data ) === false ) {
 throw new Error('No se puede escribir el fichero de caché');
 }
 fclose($h);

 }

 // Obtenemos el nombre del fichero codificado
 private function getFileName($key) {
 return  $this->cacheDir.md5($key);
 }

 // Recuperamos de caché
 function get($key) {

 $filename = $this->getFileName($key);
 if (!file_exists($filename) || !is_readable($filename)) return false;

 $data = file_get_contents($filename);

 $data = @unserialize($data);
 if (!$data) {
 unlink($filename);
 return false;
 }
 if (time() > $data[0]) {
 unlink($filename);
 return false;
 }
 return $data[1];
 }
}

Esta clase ya me permite especificiar de una forma cómoda el tiempo que quiero que se cachee un contenido determinado.

$cache = new Cache('cache/');
if (!$data = $cache->get('misdatos')) {
 ....
 $cache->put('misdatos', $misdatos, 60); // 60 seg
}

Rendimiento

Este sistema es muy cómodo, pero hay que ser conscientes de los problemas de rendimiento que presenta. Hemos de pensar que cada comprobación pasa por leer el contenido del fichero, convertir el objeto serializado y comprobar la fecha de este último.

Esto, frente a la simple consulta de la última fecha de modificación hace que este método sea considerablemente más lento. Pero por contra es bastante más flexible.

Mejoras

Bueno, despues de todo el rollo os propongo un juego. ¿Como lo podemos mejorar?

Mi opción

La opción que estaba barajando era la de generar un fichero con la fecha de caducidad del fichero y el nombre del fichero. De esta forma, únicamente tendría que hacer una lectura de fichero para cargar la fecha de caducidad asociada al fichero y despues mediante filemtime() comprobar si esta es superior a la especificada.

Ejemplo

<?php
...

// Leer
$content = file_get_content($file);
$times = unserialize($content);

 if (filemtime($cache_file) > $times[$cache_file]) {
 ....
 // Generamos de nuevo la caché
 $times[$cache_file] = time() + 60; // 60 seg.
 }

// Grabar
serialize(array(
 md5("tmp".time()).".cache" => '123456789'
 ....
));

...
?>

¿Alguna idea más?

WordPress está desarrollado en PHP, y en ese lenguaje tenemos herramientamientas para conocer el navegador del usuario que te está visitando. Este dato, puede ser crucial para condicionar la salida por pantalla de nuestro código, por esto, WordPress dispone de una serie de variables que podemos usar en nuestros script con el fin de conocer el navegador que nos visita:

global $is_lynx, $is_gecko, $is_IE, $is_opera, $is_NS4, $is_safari, $is_chrome, $is_iphone;

Mediante el uso de estas variables booleanas (true o false) podremos conocer el navegador que usa nuestro usuario. Incluso podemos generarnos una función que nos facilite la comprobación de cada una de las variables.

add_filter('body_class','browser_body_class');
function browser_body_class($classes) {
	global $is_lynx, $is_gecko, $is_IE, $is_opera, $is_NS4, $is_safari, $is_chrome, $is_iphone;

	if($is_lynx) $classes[] = 'lynx';
	elseif($is_gecko) $classes[] = 'gecko';
	elseif($is_opera) $classes[] = 'opera';
	elseif($is_NS4) $classes[] = 'ns4';
	elseif($is_safari) $classes[] = 'safari';
	elseif($is_chrome) $classes[] = 'chrome';
	elseif($is_IE) $classes[] = 'ie';
	else $classes[] = 'unknown';

	if($is_iphone) $classes[] = 'iphone';
	return $classes;
}

Este código añadirá automáticamente al class del tag <body /> el navegador de nuestro usuario, permitiéndonos personalizar la apariencia del blog dependiendo de dicha versión.

Alguna de las rutinas que debemos tener siempre presentes es la de hacer copias de seguridad periódicas de nuestros datos. Y es que más vale prevenir que curar.

Una buena práctica es la de programar copias de seguridad cada X tiempo (dependiendo de la importancia de los datos) y esa copia enviarla por email. Servicios como gMail son ideales para estas cosas ya que tienen una capacidad importante y teóricamente están online el 100% del tiempo.

En mi caso, cada noche se realiza un backup de todas las bases de datos y automáticamente me envia un email que posteriormente (y gracias a un filtro aplicado a los emails) estos mails son almacenados en una etiqueta de mi cuenta de correo en gMail.

Backup2Mail

Se trata de un pequeño PHP que se encarga de realizar el backup automáticamente por nosotros y enviarlo por email al que nosotros le hayamos especificado.

Configuración

/***************************************************
	Database settings
****************************************************/
	$db_server		    = 'localhost'; // Database server, usually "localhost"
 	$db_name 		    = '';	   // Database name, leave empty for 'all databases'
	$db_user 		    = '';	   // Database username
	$db_pass 		    = '';	   // Database password

/***************************************************
	E-mail settings
****************************************************/
 	$website            = 'yoursite.com';			// Your site's domain (without www. part)
	$send_to 	    = 'mail@yoursite.com';		// backup file will be sent to?

Es realmente sencillo, si editamos el fichero index.php que podemos descargar directamente desde aquí, encontraremos las 4 opciones necesarias para configurar el script. Simplemente introduciendo los datos de nuestra base de datos y el email al que queramos enviar el fichero de base de datos ya tendremos configurado nuestro script.

Automatizando

Ahora solo nos queda hacer que nuestro script se ejecute cada X tiempo, para ello haremos uso del demonio Cron (en Linux) que nos permitirá especificar el momento en el que se ejecute.

// cada minuto
* * * * *	php /home/your_account/backup2mail/index.php >/dev/null 2>&1 

// cada día a media noche
0 0 * * *	php /home/your_account/backup2mail/index.php >/dev/null 2>&1 

// cada día a las 05:00
0 5 * * *	php /home/your_account/backup2mail/index.php >/dev/null 2>&1 

// cada Domingo a media noche
0 0 * * 0	php /home/your_account/backup2mail/index.php >/dev/null 2>&1

Para más información sobre como funciona Cron, revisar este manual.