Usando y extendiendo PDO (I)

PDO (PHP Data Objects) es una librería estándard disponible a partir de PHP5.0 como extensión PECL y en PHP5.1 como librería de serie que se puede usar para acceder a distintas bases de datos.

Es un buen hábito usar los recursos del lenguaje sin dependencias adicionales, y en muchos servidores ya está disponible PHP5.2, así que disponer de PDO es bastante normal.

PDO ofrece una interfaz orientada a objetos que se puede extender con facilidad.

Existen numerosos ejemplos en internet sobre cómo usarla, así que no me extenderé en ello. Me centraré especialmente en cómo usar PDO para programar de forma sencilla y eficiente.

PDO define dos clases: PDO y PDOStatement.

Acceder al objeto PDO

Generalmente tendremos una única conexión con una base de datos y para acceder al objeto PDO de esa conexión desde cualquier sitio (incluido funciones) necesitaremos o bien una variable global o bien un campo estático con el objeto.

Generalmente la gente suele optar por una variable global tipo $dblink o similares. Y para acceder a ella genéricamente desde una función o desde el ámbito global, necesitaremos acceder a ella con la superglobal $GLOBALS: $GLOBALS['dblink'] o explicitando su uso mediante el keyword global: global $dblink;

Cualquiera de las dos soluciones es un poco engorrosa. Yo últimamente estoy usando la opción de campo estático y me está dando muy buenos resultados:

class db {
static $db;
}

Para acceder al objeto PDO, bastaría con usar db::$db, que además de ser mas corto es mas fácil de escribir y tiene en parte un poco mas de sentido. Además usando la característica __autoload que ya he comentado, podemos hacer que se incluya a demanda la clase db y podemos hacer que en el fichero que esté definida la clase db, se encargue de hacer la conexión, de forma que mágicamente al acceder a db::$db obtendremos un objeto PDO con la conexión y si no, no se llegará a conectar (si no es necesario) y sin tener que estar con require_once o similares cada dos por tres.

Además podemos usar la clase db para ciertas utilidades SQL. Es bastante habitual hacer inserts sencillos o updates que cambien una sola fila mediante un id y similares. Así que en class db. Me he puesto un par de métodos estáticos para generar queries de UPDATE e INSERT dada una tabla, un array asociativo y para el caso del UPDATE, una condición.

En el caso del array asociativo del UPDATE tengo un caso especial que ocurre cuando el nombre de un campo empieza por '*', en cuyo caso el valor será una expresión (para cosas tipo NOW() y similares).

php5.1 y spl_autoload_register

Desde php5.1 disponemos de spl_autoload_register (desde php5.0 podemos definir la función __autoload).

En php5 si se define una función __autoload, ésta se llamará cada vez que se intente acceder a una clase que no exista. Tanto a un método estático como a la creación de un nuevo objeto de ese tipo.

Ésto nos permite cargar código implícitamente y olvidarnos de incluir dependencias continuamente y permitiéndonos hacer algunas cosas mas lightweight sin tener que cargar cosas que no nos interesan.

Aunque nos obliga a usar clases.

Para agrupar funciones útiles que usemos comúnmente se puede hacer una clase "util" y luego métodos estáticos. Por ejemplo, yo suelo usar muy amenudo una función que llamo print_r_pre que se encarga de hacer lo mismo que un print_r, pero para que se vea correctamente en la web (usando <pre> y htmlspecialchars). Pues bien, me podría hacer una clase "util" con la función ahí:

class util {
 static function print_r_pre($v) {
    echo '<>' . htmlspecialchars(print_r($v, true)) . '< /pre>';
 }
}

Lo metería, por ejemplo, en un fichero llamado util.php en una carpeta creada para usar con la característica __autoload. Por ejemplo: /core/classes/util.php

Y luego en un fichero que sí que debería cargar cada vez algo tipo esto (suponiendo que el fichero que inclue este código esté en /core/):

function __autoload($class) {
 if (!file_exists($file = dirname(__FILE__) . '/classes/' . $class . '.php'))    return;
 require_once($file);
}

Conclusión:
Si estás usando php5 y quieres ahorrarte mogollón de requiere_once. Las soluciones __autoload son para tí.

echo vs printf vs strtr/str_(i)replace vs preg_replace_callback

Introducción:

En muchas ocasiones querremos separar el texto de nuestras páginas web de la programación propiamente dicho. En ocasiones será para poder localizar nuestra página (tenerla en diferentes idiomas), otras simplemente por comodidad.

Dichos textos, generalmente estarán mezclados con contenido dinámico que se tendrá que reemplazar.

Supongamos que tenemos una página con categorías y entradas de algún tipo y queremos mostrar en el título el camino a una subcategoría, y la cantidad de subcategorías y de elementos que tiene.

Podríamos hacer algo similar a esto usando echo:

echo htmlspecialchars('Categoría: ' . implode(' > ', $path) . ' Subcategorías: ' . (int)$categories_count . ' Entradas: ' . (int)$entries_count);




No es difíl darse cuenta de que, aunque funciona, es difícilmente actualizable; especialmente si la persona que tiene que retocarlo no sabe programar. Además si quisiesemos traducirlo a otros idiomas tendríamos que traducir cada parte individualmente (con el echo).

Otra alternativa es usar la función printf, que permite crear una cadena de formato separada de los datos y nos permite una separación cómoda y eficiente; además de que facilita mucho todo lo referente a la localización de texto.

Con printf, podríamos hacer algo similar a esto:

define('TITLE_CATEGORY','Categoría: %s Subcategorías: %d Entradas: %d');
printf(TITLE_CATEGORY, implode(' > ', $path), (int)$categories_count, (int)$entries_count));

El define (o una posible variable global o clave en un array), puede estar en un fichero distinto con todos los textos a localizar o a modificar de fácil acceso. También puede estar en una base de datos o en un fichero de texto que pueda editar otra persona. Además nos permitiría dar formato a los números o a las cadenas.

Por otra parte perdemos la posibilidad de cambiar de orden los elementos. El printf requiere que los elementos estén en orden.

Con strtr o con str_replace o str_ireplace podemos conseguir una "cadena de formato" que permita cambiar el orden de los elementos de una forma ligera y eficiente:

define('TITLE_CATEGORY', 'Categoría: {categories} Subcategorías: {categories_count} Entradas: {entries_count}');
echo htmlspecialchars(strtr(TITLE_CATEGORY, array(
'{categories}' => implode(' > ', $path),
'{categories_rev}' => implode(' < ', array_reverse)($path)),
'{categories_count}' => (int)$categories_count,
'{entries_count}' => (int)$entries_count)
)));




Se puede ver que he añadido una opción categories_rev, por si la persona que se encarga de traducir o de retocar los textos de la página determina que sería interesante colocar las categorías mas internas antes que las mas generales (por ejemplo para optimización para motores de búsqueda). Con prg_(i)replace, podríamos conseguir el mismo efecto que con strtr, si en vez de usar un array asociativa, usamos dos arrays, uno con las claves y otro con los valores.

Para finalizar decir que con preg_replace y preg_replace_callback, podemos conseguir un reemplazado mucho mas potente, aunque algo mas complejo y lento. Pondré un ejemplo en el que se nos permite aplicar una función a un parámetro y obtener los parámetros:

function my_function($v) {
return strtr($v, 'aeios', '43105');
}

function my_replace_callback($k) {
$rl    = &$GLOBALS['my_replace_list'];
$funcs = &$GLOBALS['my_replace_list_funcs'];

$k = explode(':', $k[1]);
$key = array_shift($k);
$r = isset($rl[$key]) ? $rl[$key] : $key;

while (sizeof($k)) {
   $func = array_shift($k);
   if (in_array($func, $funcs)) $r = $func($r);
}

return $r;
}

function my_replace($t, $l, $f) {
$GLOBALS['my_replace_list'] = $l;
$GLOBALS['my_replace_list_funcs'] = $f;
return preg_replace_callback('/\\{([^\\}]+)\\}/', 'my_replace_callback', $t);
}

$path = array('objetos', 'inanimados', 'escolar', 'escritura');

define('TITLE_CATEGORY', 'Categoría: {categories:my_function:strtoupper} Subcategorías: {categories_count} Entradas: {entries_count}');

echo htmlspecialchars(my_replace(TITLE_CATEGORY, array(
'categories'       => implode(' > ', $path),
'categories_rev'   => implode(' < ', array_reverse($path)),
'categories_count' => 10,
'entries_count'    => 100,
), array('strtoupper', 'trim', 'my_function')));

Conclusión:

• echo es práctico y rápido para cosas sencillas que no requieran formato y que no se tengan que modificar o traducir.
• printf es práctico para cadenas que requieran formato y una localización sencilla.
• echo+strtr nos permite dar un formato ligero pero más potente que las otras dos opciones.
• echo+preg_replace_callback nos permite dar un formato mas pesado, pero tremendamente flexible, útil incluso para templates.

Generalmente echo+strtr suele dar muy buenos resultados para localización de texto, y ofrece un código compacto de bastante rendimiento y sin ninguna dependencia adicional.

Introducción

Nuevo blog de programación en PHP.

Tras largos años de experiencia con PHP he ido enfrentándome a numerosos problemas que he ido resolviendo cada vez mejor. He desarrollado técnicas para montar páginas en php ligeras, eficientes y robustas.

Internet está repleta de información sobre la programación en PHP, pero hay poca información sobre buenos hábitos, y técnicas de programación avanzadas y la poca que hay está en inglés.

Este blog tratará sobre programación avanzada en PHP y técnicas para hacer una programación sencilla y eficiente.

Explicaré también algunas técnicas nuevas que he desarrollado para el relativamente reciente PHP5 y sus nuevas características. Aunque muchas de las técnicas serán compatibles tanto con PHP5 como con el antiguo PHP4. No trataré temas de PHP3 ni por supuesto PHP/FI.