phpElegante

Referencias en PHP y funciones útiles auxiliares

2010-07-14T12:55:00.008+02:00

Uno de los aspectos interesantes de PHP es la gestión de referencias.
Como es bien sabido en PHP, intentar acceder a una variable o una clave en un array que no existe produce un notice y generalmente hay que estar tratando continuamente con isset y con bastantes código redundante.
El caso es que PHP permite crear una referencia a una variable inexistente para crearla a posteriori. Es como crear un slot de la variable en potencia y asignarlo si así se decide. También permite comprobar la existencia de la variable referenciada usando la variable de referencia.

Es bastante típico en PHP querer obtener el valor de una variable si existe, o un valor por defecto en el caso de que no exista. Ejemplo:

$page = isset($_GET['page']) ? $_GET['page'] : 1;

En PHP 5.3 se añadió un shortcut del operador ternario. A priori parecía bastante interesante, porque teóricamente hubiese podido permitir hacer esto: $page = $_GET['page'] ?: 1;
Pero resulta que la cagaron estrepitosamente. Resulta que lo que hace el shortcutdel ternario es evaluar la parte de la izquierda y si al castear implícitamente a bool, el resultado es false, se devuelve el resultado de la expresión de la derecha. Esto para empezar no evita el tema de los notices al intentar acceder a una clave inexistente en el array. Además hay un pequeño matiz que difiere con el isset. Y es que si la variable existe pero tiene un valor evaluado como false (como una cadena vacía o el valor 0), ya se estaría devolviendo lo de la derecha. Y generalmente no es lo deseado.
Así que veo completamente inútil esta adición al PHP 5.3.

Sin embargo PHP y sus referencias permiten crear funciones auxiliares que permiten resolver estos problemas con facilidad y evitando repetir la variable dos veces:

$page = isset_default($_GET['page'], 1);

Ésto es posible sin notices porque en las últimas versiones de PHP especificas los valores que se pasan por referencia en la propia descripción de la función. Así pues:

function isset_default(&$var, $default) {
    return isset($var) ? $var : $default;
}

Esto vendría a ser como una macro bastante útil.

También es bastante común comprobar la existencia de varias claves en un array.

if (isset($_GET['a'], $_GET['b'], $_GET['c'])) { }

if (isset_array($_GET, array('a', 'b', 'c'))) { }

Aquí la referencia evita que PHP duplique un array potencialmente grande.

function isset_array(array &$array, array $keys) {
    foreach ($keys as $key) if (!isset($array[$key])) return false;
    return true;
}

Otro patrón común que se puede resolver con macros de referencias es hacer un cambio a posteriori de una variable.

function method() {
    if ($this->alreadyPerformed) return;
    $this->alreadyPerformed = true;
    ...
}

function method() {
    if (post_assign($this->alreadyPerformed, true)) return;
    ...
}

function post_assign(&$var, $value) {
    $last_value = $var;
    $var = $value;
    return $last_value;
}

En este caso concreto también se podría usar el pequeño truco de usar enteros para evitar tener la variable dos veces referenciada. Y usar el operador unario del postincremento:

function method() {
    if ($this->alreadyPerformed++) return;
    ...
}

Hay muchas formas útiles de usar las referencias en PHP. Por ejemplo para tener una caché temporal en memoria muy ligera:

static function cached_method($key) {
    static $cache = array();
    $result = &$cache[$key];
    if (!isset($result)) {
        // ...
    }
    return $result;
}

Con referencias y PHP 5.3:

function &cache_result(&$var, $func) {
    if (!isset($var)) $var = $func();
    return $var;
}

static function cached_method($key) {
    static $cache = array();
    return cache_result($cache[$key], function() use ($key) {
         // ...
    });
}

Otras funciones que considero útiles aunque no tengan que ver directamente con referencias:

Por ejemplo si queremos obtener una array a partir de otro sin las claves que empiezan por _:

$array = array_filter_keys($_GET, function($key) { return substr($key, 0, 1) != '_'; } );

function array_filter_keys(&$array, $callback) {
    $result = array();
    foreach ($array as $key => $value) {
        if ($callback($key, $value)) $result[$key] = $value;
    }
    return $result;
}

En determinadas ocasiones queremos ver un array visualmente que contiene html. Con xdebug la functión var_dump puede estar coloreada. Pero ni siempre está disponible el xdebug, ni tampoco es siempre lo más cómodo visualmente. Aquí hay una función que permite mostrar un print_r para html. Haciendo uso del tag pre y del escapado de html.

function print_r_pre($var) {
    echo '<pre>';
    echo htmlspecialchars(print_r($var, true));
    echo '</pre>';
}

Trabajando con objetos en base de datos con PDO y Mongo + Demo con Twig

2010-06-02T13:13:00.010+02:00

Trabajar con resultados de bases de datos como si fuesen objetos permite trabajar de una forma muy cómoda e intuitiva. PDO tiene soporte nativo para devolver instancias de una clase en vez de arrays. Pero con MongoDB tampoco es mucho más complicado conseguir un iterador de objetos de una clase determinada.
Aquí coloco un ejemplo con PDO, Mongo y Twig. Con twig se ve claramente la comodidad de tener objetos con los que poder llamar métodos que produzcan datos derivados sin tenerlos que generar explícitamente (on demand).
He creado una clase derivada de IteratorIterator y un método estático usando late static binding para poder castear un array/objeto a una nueva instancia de una clase especificada.




class CastModelIteratorIterator extends IteratorIterator {
    public $class;

    function current() {
        return Model::cast(parent::current(), $this->class);
    }
}

class Model {
    static public function cast($array, $class = null) {
        $object = ($class === null) ? (new static) : (new $class);
        foreach ($array as $k => $v) $object->$k = $v;
        return $object;
    }
    
    static public function castIterator($iterator) {
        $iterator = new CastModelIteratorIterator($iterator);
        $iterator->class = get_called_class();
        return $iterator;
    }
}

class TestModel extends Model {
    public $name, $pass;

    function __construct($name = 'test') {
        $this->name = $name;
        $this->pass = self::hashPassword('test');
    }
    static function hashPassword($password) {
        return md5("{$password}*");
    }
    function checkPassword($password) {
        return $this->pass == self::hashPassword($password);
    }
    function url() {
        return sprintf('/user/%s', urlencode($this->name));
    }
}

// Sqlite PDO Test
{
    $db = new PDO('sqlite::memory:');
    $db->query('CREATE TABLE TestModel (name, pass);');
    $t = $db->prepare('INSERT INTO TestModel (name, pass) VALUES (?, ?);');
    $model = new TestModel('Test');
    $t->execute(array($model->name, $model->pass));
    foreach ($db->query('SELECT * FROM TestModel;', PDO::FETCH_CLASS, 'TestModel') as $e) {
        printf("%s\n", $e->url());
    }
}

// Mongo Test
{
    $mongo = new Mongo(); // connect
    $db = $mongo->demo;
    $collection = $db->TestModel;
    $collection->remove();
    $collection->insert(new TestModel('Test'));

    foreach (TestModel::castIterator($collection->find()) as $e) {
        printf("%s\n", $e->url());
    }
}

// Twig
{
    require_once(__DIR__ . '/Twig/Autoloader.php');
    Twig_Autoloader::register();
    $collection->insert(new TestModel('Demo'));

    $twig = new Twig_Environment(new Twig_Loader_String(), array(
        'debug'       => true,
        'auto_reload' => true,
    ));

    $twig->loadTemplate('
        <ul>{% for item in list %}
<li><a href="{{ item.url }}">User {{ item.name }}</a></li>
{% endfor %}</ul>
')->display(array(
        'list' => TestModel::castIterator($collection->find()),
    ));
}

Trabajando con archivos binarios en PHP

2010-06-01T23:22:00.001+02:00

Aunque PHP no es un lenguaje de programación muy adecuado para trabajar con archivos binarios, en determinadas circunstancias puede ser de utilidad. Y explicaré aquí algunos detalles a tener en cuenta al trabajar con archivos binarios y técnicas para hacerlo con sencillez.

fopen. Flag 'b' para binarios en windows.
A la hora de abrir archivos, existen diversos modos: de escritura (write only), de lectura (read only), de lectura/escritura (read/write), de escritura situando el cursor al final del archivo (append). Además hay un flag que permite especifica si el archivo a abrir se usará como un archivo de texto o como uno binario. En modo texto es posible que un salto de línea (\n) se guarde como dos bytes \r\n dependiendo del sistema operativo. Y esto puede causar archivos corruptos en muchos casos. Nota: El flag opuesto a 'b' es 't'. Puede producir problemas también con ftell. Se recomiendo usar siempre el flag 'b' para que la compatibilidad sea la misma indistintamente de la plataforma.

pack, chr / unpack + list, ord
Estas funciones sirven para empaquetar y desempaquetar valores numéricos y cadenas en datos binarios. Y son el pilar fundamental de una codificación/decodificación fácil y cómoda:

ord (ordinal) obtiene el valor numérico que tiene un carácter. Se le pasa una cadena y lo calcula a partir del primer byte de la cadena
chr (character) obtiene el carácter de un valor numérico (la función inversa a ord).
Ambas funciones trabajan a nivel de byte y únicamente trabajan con el rango de 00-FF.

chr(ord('a')) == 'a'

pack permite empaquetar una serie de valores en un formato binario. La función proviene de perl. Se le pasa una cadena con el formato de empaquetado y luego una sucesión de parámetros con los valores a empaquetar. El formato de empaquetado contempla valores con signo y sin signo de 8, 16 y 32 bits pudiendo especificar el endian: usando el de la máquina actual, o usando little o big endian. También permite empaquetar cadenas terminadas con '\0's o con espacios.

unpack permite desempaquetar una serie de valores a partir de una cadena binaria. Si no se especifican nombres para los datos desempaquetados, se devuelve un array de claves numéricas empezando por la clave 1 (en vez de por la clave 0). Para extraer valores en variables con comodidad se puede usar la estructura del lenguaje "list". Teniendo en cuenta que el casting de array a bool es siempre true, se puede usar una asignación intrínseca y el operador ternario para hacer una extracción en una única expresión.

list(, $valor) = unpack('s', "\xFF\xFF");

list($valor) = array_values(unpack('s', "\xFF\xFF"));

$valor = ($v = unpack('s', "\xFF\xFF")) ? $v[1] : false;

echo $valor;

Tip:

pack('H*', '736f7977697a')

Las funciones pack usando H*, permiten convertir datos en hexadecimal a cadenas binarias y viceversa. (ver funciones hex/unhex de las funcionesde utilidad del final del artículo)

fseek (archivos grandes)

PHP trabaja con dos tipos numéricos: signed int (32 bits) y double (64 bits) de los cuales se pueden conseguir 53 bits para valores enteros (sin decimales) que son unos 16 digitos decimales.
$a = 0x7FFFFFFF; var_dump($a); $a++; var_dump($a); var_dump((int)$a);

int(2147483647)
float(2147483648)
int(-2147483648)
El problema es que fseek trabaja con enteros de 32 bits y el direccionamiento de fseek y ftell de archivos está limitado a eso en PHP. Que son 2GB sin signo y 4GB con signo. Diría que se puede superar este límite haciendo varias llamadas con SEEK_CUR.

substr

La función substr nos permite extraer determinados bytes de una cadena binaria como si fuese una cadena de texto normal. Donde cada caracter es un byte.

Nota:
En la configuración de PHP hay una opción llamada "mbstring.func_overload" que permite susitutir las funciones normales. Esto permite hacer que las funciones normales para trabajar con cadenas se sustituyan por sus equivalentes mb_*. Esto es un problema que puede llevar a verdaderos quebraderos de cabeza cuando se trabaja con cadenas binarias.

Una solución pasa por:
$back_encoding = mb_internal_encoding();

mb_internal_encoding('8bit');

// Hacer cosas.

mb_internal_encoding($back_encoding);

O directamente utilizar las funciones mb_* usando 8bit como el encoding normal.
Así que para extraer los primeros 10 bytes:
substr($cadena, 0, 10);
->
mb_substr($cadena, 0, 10, '8bit');

Con el resto de funciones de cadena tipo strlen pasa exáctamente lo mismo.

acceso como array [] {}
PHP permite acceder a las cadenas como si fuesen arrays. Tanto para lectura como para escritura.
Así que:
$str = 'abc';
$str[1] == substr($str, 1, 1);

$str[1] = 'a';
$str = substr_replace($str, 'a', 1, 1);

$str == 'aac'

streams: php://memory, php://temp, data://, file_get_contents
En lenguajes que soportan slicing de streams, leer y procesar archivos binarios suele ser bastante mas cómodo. PHP no soporta slicing de streams directamente, y aunque se puede hacer un apaño, no se soporta nativamente. Sin embargo la lectura secuencial de datos y el "consumo" de datos es un patrón básico en el procesado de archivos binarios medianamente complejos. Los streams son muy cómodos para la consumición de datos ya que tiene un cursor y un torrente de datos y cada vez que lees, se actualiza ese cursor. En determinadas ocasiones tendremos los datos que queremos consumir en una cadena binaria, por ejemplo tras obtenerlos directamente con file_get_contents, tras generarlos por otro medio o al leer un subtream en una cadena.
Una función que puede permitir la consumición de datos en una cadena podría ser esta:
function fread_str(&$str, $len) { $data = substr($str, 0, $len); $str = substr($str, $len); return $data; }
Aunque esta forma de procesar datos es muy poco eficiente. Porque estás reconstruyendo una cadena todo el rato, copiando datos contínuamente y en cadenas grandes puede ser un proceso muy costoso.
otra forma es tener un cursor, de forma que evitamos tocar la cadena y únicamente extraemos la parte que nos interesa:

function fread_str_cur(&$cur, &$str, $len) { $data = substr($str, $cur, $len); $cur += $len; return $data; }

En PHP se puede generar un stream a partir de una cadena con relativa facilidad. Hay diversas formas:

$f = fopen('data://text/plain;base64,' . base64_encode($data), 'r+');

$f = fopen('php://memory', 'w+'); fwrite($f, $data); fseek($f, 0);

rtrim+\0
Al trabajar con archivos binarios, suele trabajarse con stringz muy amenudo o con cadenas que tienen un right padding de o bien espacios o bien el carácter 0.
La función rtrim nos puede ayudar a eliminar esos caracteres sobrantes de la cadena. rtrim tiene un segundo parámetro opcional que permite especificar los caracteres a eliminar. En nuestro caso \0. Por defecto elimina espacios, tabuladores, saltos de línea y el carácter \0. Pero en estos casos nos interesa únicamente que elimine el carácter de padding:
rtrim("hola\0\0\0", "\0") == 'hola'

Algunas funciones de utilidad:
function fread1($f) { @list(, $r) = unpack('C', fread($f, 1)); return $r; }

// Little Endian.

function fread_str(&$str, $len) { $data = substr($str, 0, $len); $str = substr($str, $len); return $data; }

Variantes:

function fread1($f) { return ord(fread($f, 1)); }

function fread2le($f) { return ($v = unpack('v', fread($f, 2))) ? $v[1] : false; }

function fread4le($f) { return ($v = unpack('V', fread($f, 4))) ? $v[1] : false; }

function freadsz($f, $l = false) {

if ($l === false) {

$s = '';

while (!feof($f)) {

$c = fread($f, 1);

if ($c == '' || $c == "\0") break;

$s .= $c;

}

return $s;

} else {

return rtrim(fread($f, $l), "\0");

}

Simulate static binding on PHP < 5.3

2010-01-18T11:25:00.001+01:00

class A {
const CONSTANT = 'A';

function __construct() {
echo constant(get_class($this) . '::CONSTANT');
// echo self::CONSTANT; // No static. Would output AA instead of AB.
// echo static::CONSTANT; // PHP >= 5.3
}
}

class B extends A {
const CONSTANT = 'B';
}

ob_start();
$a = new A;
$b = new B;
var_dump(ob_get_clean() == 'AB');

?>

Macro operaciones con las funciones array_*

2009-10-20T10:34:00.003+02:00

Quitar todos los espacios de principio y de final de cada elemento en un array (array_map):

$array_trimmed = array_map('trim', $array);
Alternativas:
$array_trimmed = array(); foreach ($array as $v) $array_trimmed[] = trim($v);
foreach ($array_trimmed as &$v) $v = trim($v); // Mala idea. PHP tiene leaks desde hace mucho tiempo con foreach + &.

Obtener una lista segura de enteros (por ejemplo IDs) para insertar en una query dentro de un IN().
$array_str_list = implode(',', array_map('intval', $array));

Filtrar un array obteniendo únicamente valores numéricos (array_filter):
$array_numbers = array_filter($array, 'is_numeric')

Para creación de valores para un insert con pdo (array_map):

$query_insert_values = implode(",", array_map(array($pdo, 'quote'), $values))

Para creación de asignaciones en un update con pdo (array_map con dos arrays):
$query_set = implode(',', array_map(function($k, $v) use ($pdo) {
return '`' . implode('`,`', explode('.', $k)) . '`=' . $pdo->quote($v);
}, array_keys($array), array_values($array)));

Obtener una lista de elementos únicos usando un array que contiene un número indeterminado de arrays (array_reduce):

$array_unique = array_unique( array_reduce( $arrays, 'array_merge', array() ) );

Crear "estructuras" en php5.3

2009-07-19T17:06:00.000+02:00

En alguna ocasión me ha interesado crear una clase que contendría simplemente unos cuantos atributos y poco más y al final he acabado haciendo un constructor del tipo:

class mystruct { 

    public $a, $b, $c;

    function __construct($a, $b, $c) {

        $this->a = $a;

        $this->b = $b;

        $this->c = $c; 

}

}

class struct {

    static public function create() {

        $obj = new static;

        $keys = array_keys((array)$obj);

        foreach (func_get_args() as $k => $v) $obj->{$keys[$k]} = $v;

        return $obj;

    }

}

Para versiones anteriores de php podemos usar el constructor:

class struct {

    static function __construct() {

        $keys = array_keys((array)$obj);

        foreach (func_get_args() as $k => $v) $this->{$keys[$k]} = $v;

        return $this;

    }

}

Con lo que podríamos hacer lo siguiente:

class mystruct extends struct { public $a, $b, $c; }

mystruct::create(1, 2, 3);

o
new mystruct(1, 2, 3);

Novedades con phpSTE

2009-07-17T01:57:00.005+02:00

Ahora que vuelvo a tener Internet en plan bien, y ya vuelvo a estar con mis proyectos, he seguido mejorando phpSTE.

He cambiado bastantes cosas desde que lo empecé, y cambiaré bastantes más posiblemente hasta que esté pulido del todo.

Por ahora ocupa unas 550 líneas y ya es bastante funcional.

Además de soportar herencia, he añadido los siguientes tags:

{extends name=""} - extiende un template.
{include name=""} - incluye un template.
{block name=""}{/block} - define e imprime/modifica un bloque.
{addblock name=""}{/addblock} - modifica un bloque añadiendo el contenido al final.

{blockdef name=""}{/blockdef} - define un bloque sin utilizarlo.
{putblock name=""} - imprime un bloque existente.

{t}{/t} - llama a la función de gettext

{if cond=""}{/if}
{elseif cond=""}{else}

{for var="" from="" to="" step=""}{/for}

{foreach list="" var=""}{/foreach}

He hecho optimizaciones para que los tags puedan saber si el contenido es un literal, de forma que {t}Texto{/t} se convertiría a mientras que {t}{if cond=1}Texto{/if}{/t} se convertiría a Texto

phpSTE

2009-07-06T00:41:00.001+02:00

phpSTE (PHP Simple Template Engine) es un sistema de templates que he empezado a hacer hoy.

Se caracteriza por ser liviano, rápido y sencillo. Actualmente no es 100% funcional, ni lo he testeado lo suficiente, pero ya empieza a hacer cosas.

Además, soporta herencia de templates.

Está programado para PHP5.3 o superior. Hace uso de namespaces, late static binding y alguna otra cosa de esta versión.

http://code.google.com/p/phpste/

La idea es que el engine terminado no supere las 1000 líneas de código comentado y que esté todo en un único archivo para facilitar al máximo su inclusión en otros proyectos.

Calculando el número de apariciones de un color en una imagen paletizada usando GD.

2009-06-05T16:20:00.002+02:00

$i = imagecreate(1000, 1000);

$c1 = imagecolorallocate($i, 0x00, 0x00, 0x00);
 $c2 = imagecolorallocate($i, 0xFF, 0xFF, 0xFF);
 
 imagefill($i, 0, 0, $c2);
 
 for ($n = 0; $n < 100; $n++) imagesetpixel($i, $n, $n, $c1);

 printf("Method1 (iterating using php) {\n");
 {
  $t0 = microtime(true);
  ob_start(); imagegd($i); $data = substr(ob_get_clean(), 0x40D);
  printf("  Output image: %.4f seconds\n", microtime(true) - $t0);

  $t0 = microtime(true);
  $count = array();
  list($w, $h) = array(imageSX($i), imageSY($i));
  for ($y = 0; $y < $h; $y++) {
   for ($x = 0; $x < $w; $x++) {
    @$count[imagecolorat($i, $x, $y)]++;
   }
  }
  $count = count_chars($data, 1);
  arsort($count);
  printf("  Counting: %.4f seconds\n", microtime(true) - $t0);
  print_r($count);
 }
 printf("}\n");
 
 printf("Method2 (hack) {\n");
 {
  $t0 = microtime(true);
  ob_start(); imagegd($i); $data = substr(ob_get_clean(), 0x40D);
  printf("  Output image: %.4f seconds\n", microtime(true) - $t0);

  $t0 = microtime(true);
  $count = count_chars($data, 1);
  arsort($count);
  printf("  Counting: %.4f seconds\n", microtime(true) - $t0);
  print_r($count);
 }
 printf("}\n");

El último día de un mes en php5

2009-05-20T14:38:00.000+02:00

Mes anterior:
date_create(date('Ym01'))->modify('-1 day')

Este mes:
date_create(date('Ym01'))->modify('+1 month -1 day')

Un mes concreto mediante timestamp:
date_create(date('Ym01', $timestamp))->modify('+1 month -1 day')

Ejemplo de RPG 2D en phpmedia

2009-05-05T08:45:00.000+02:00

Aprovechando que hacía tiempo hice una prueba de minirpg en javascript, y luego un port en flash online y con chat (cliente+servidor en D) y que ya tenía los gráficos y las animaciones, he portado eso mismo a php usando phpmedia.

Los gráficos son de Tales of Eternia (juego que traducimos al español hace unos años). Con un filtro 2xsai o 2xeagle si no recuerdo mal. Los personajes que se usan en la demo son Reid y Farah. Mientras que el escenario (que todavía no está puesto ya que es solo una demo de colisiones), es el Dojo de Regulus.

Prueba de RPG 2D en phpmedia

Y llegaron los shaders...

2009-04-25T05:01:00.003+02:00

Ya se puede usar GLSL en phpmedia:

Ejemplo: http://phpelegante.googlepages.com/phpmedia_test_glsl.7z

error_reporting(E_ALL | E_STRICT);

Screen::title('Shader test');
$screen = Screen::init(800, 600);
$key = 'Keyboard';

$shader = new Shader("
uniform sampler2D image, mask;
uniform float step;
void main (void) {
gl_FragColor.rgb = texture2D(image, vec2(gl_TexCoord[0])).rgb;
gl_FragColor.a = texture2D(mask , vec2(gl_TexCoord[1])).r + step;
}
");

$mask = Bitmap::fromFile('mask.png');
$image = Bitmap::fromFile('file.jpg');
$arrows = Bitmap::fromFile('arrows.png');

$v = -1.0;

$timer = 0;

while (!$key::pressed($key::ESC)) {
if ($key::down($key::LEFT)) $v -= 0.03;
if ($key::down($key::RIGHT)) $v += 0.03;

Math::clamp($v, -1.0, 1.0);

$screen->blit($image, 0, 0, 1, 0, 1, $shader, array('mask' => $mask, 'step' => $v));
$screen->blit($arrows, 16, 16, 1, 0, 0.6 + abs(cos($timer / 64)) * 0.8);

$timer++;
Screen::frame();
}

Ejemplo de nave (mejorado)

2009-04-24T09:21:00.001+02:00

http://phpelegante.googlepages.com/nave_shoot.7z

Ejemplo de nave

2009-04-21T08:13:00.003+02:00

He hecho un pequeño ejemplo en phpmedia 2:

http://code.google.com/p/phpmedia/wiki/SampleNave

phpMedia 2.0

2009-04-20T05:13:00.011+02:00

Hace unos 5 años, hice una extensión para php que permitía hacer aplicaciones multimedia 2D. Por aquel entonces usaba PHP4 y Allegro. Todo el tema gráfico se hacía por software y no permitía conseguir un buen rendimiento. El API no era orientado a objetos y PHP4 estaba mucho más limitado que en la actualidad. El proyecto se alojaba en sourceforge aquí.

Hace un par de semanas, decidí que estaría bien revivir aquello, pero hacerlo mucho mejor: con una interfaz orientada a objetos para PHP5.3 y usando OpenGL con aceleración completa por hardware.

Establecí un proyecto en googlecode. Y me puse a idear el API que tendría. El objetivo es conseguir un API sencillo y útil. Que no sea totalmente versatil, pero que deje hacer bastantes cosas.
Hice un prototipo de interfaz en PHP, y un generador de documentación para googlecode.

Aunque no hice nada, ya tenía mas o menos pensada parte del API.
Esta tarde/noche, me he puesto con ello. Con unos resultados muy prometedores. He tenido muy pocos problemas y ha ido todo como esperaba o incluso mejor.

Como resultado he sacado una primera versión usable, para PHP5.3. En la página del proyecto está.

Lo que he hecho:

Soporte básico de teclado. Las teclas principales. Detectar pulsaciones o detectar si está pulsada o levantada la tecla.
Inicialización gráfica (ventana o pantalla completa)
Clase Bitmap (bastante avanzada). Permite crear nuevos bitmaps, cargar desde archivos o desde cadenas. Permite hacer recortes, clonar réplicas.

Lo que falta:

Mejorar el soporte de teclado.
Soporte para ratón.
Soporte para gamepad.
Todo el tema del audio.
Shaders.

Ejemplo de prueba + archivos necesarios:

Para probar el ejemplo, bajar todos los archivos. Y ejecutar el archivo test.bat. Teclas del cursor para desplazar la imagen. W/S para acercar/alejar la imagen. A/D para rotar la imagen. ESC para salir del ejemplo.

Página del proyecto: http://code.google.com/p/phpmedia/

¿serialize o json_encode?

2009-04-17T19:39:00.004+02:00

A partir de PHP 5.2, existen dos nuevas funciones llamadas json_encode y json_decode que permiten serializar variables con contenidos variables en php. La implementación está hecha en C, así que su rendimiento es bastante conveniente.

JSON (JavaScript Object Notation) es un formato de intercambio de datos. Y tiene la peculiaridad de que la cadena generada es siempre una expresión válida en javascript. Además la cadena resultante es muy compacta, y se puede modificar con facilidad. En la actualidad ya es un formato ampliamente usado y soportado de manera oficial en muchos lenguajes de programación.

La forma más eficiente y cómoda que había hasta la fecha para serializar variables, era la opción: serialize/unserialize.

A partir de PHP 5.2, con la nueva alternativa de json_*, está la duda: ¿siendo más compatible con otros lenguajes y además compacta y flexible, podría sustituir a la original?

La respuesta es: no siempre.

json_decode puede ser mucho más lento que unserialize en muchos casos.
Mientras que serialize almacena las longitudes de las cadenas, json_encode tiene que recorrerlas para conocer su longitud. Además la entrada de json_encode tiene que ser utf-8 y el parseo es bastante más lento.

He hecho un pequeño programa para probar el rendimiento. El tamaño de la cadena generada por json siempre es más pequeño. El json se codifica mas rápido para arrays y números. Pero para cadenas, el rendimiento empeora mucho.

    function & generate_random_var( $maxdepth = 5, $base = 10, $strlen = 999 ) {
        $r = array();
        for ($n = 0, $l = mt_rand($base / 2, $base); $n < $l; $n++) {
            switch (mt_rand(0, 4)) {
                case 0: $r[] = mt_rand(); break;
                case 1: $r[] = str_repeat( '*', $strlen ); break;
                case 2: $r[] = false; break;
                case 3: $r[] = (object)array(1 => 2); break;
                case 4: if ( $maxdepth > 0 ) $r[] = generate_random_var( mt_rand( 0, $maxdepth - 1), $base, $strlen ); break;
            }
        }
        return $r;
    }

    mt_srand( 0 );

    foreach (array(
        array(4, 30, 9),
        array(10, 30, 1),
        array(0, 8000, 1),
        array(0, 8000, 99),
        array(0, 8000, 999),
        array(4, 30, 99),
        array(4, 30, 999),
    ) as $config) {
        list($maxdepth, $base, $strlen) = $config;

        printf("config(depth=%d, elements=%d, strlen=%d):\n", $maxdepth, $base, $strlen);

        $v = generate_random_var($maxdepth, $base, $strlen);

        $t = microtime(true);
        for ($n = 0; $n < 60; $n++) {
            $s = & serialize($v);
            unserialize($s);
        }
        printf(" serialize : time(%.3f), length(%d)\n", $t_serialize = microtime(true) - $t, $l_serialize = strlen($s));

        $t = microtime(true);
        for ($n = 0; $n < 60; $n++) {
            $s = & json_encode($v);
            json_decode($s);
        }
        printf(" json      : time(%.3f), length(%d)\n", $t_json = microtime(true) - $t, $l_json = strlen($s));

        printf(" diff: time(%d%%) | strlen(%d%%)\n", $t_json * 100 / $t_serialize, $l_json * 100 / $l_serialize);
        printf("\n");
    }
?>

Resultados:

config(depth=4, elements=30, strlen=9):
serialize : time(0.236), length(42431)
json      : time(0.171), length(19639)
diff: time(72%) | strlen(46%)

config(depth=10, elements=30, strlen=1):
serialize : time(0.767), length(116820)
json      : time(0.502), length(47610)
diff: time(65%) | strlen(40%)

config(depth=0, elements=8000, strlen=1):
serialize : time(0.445), length(71185)
json      : time(0.277), length(25943)
diff: time(62%) | strlen(36%)

config(depth=0, elements=8000, strlen=99):
serialize : time(0.784), length(289298)
json      : time(0.962), length(206929)
diff: time(122%) | strlen(71%)

config(depth=0, elements=8000, strlen=999):
serialize : time(1.371), length(1665092)
json      : time(5.630), length(1581304)
diff: time(410%) | strlen(94%)

config(depth=4, elements=30, strlen=99):
serialize : time(0.221), length(73598)
json      : time(0.265), length(54542)
diff: time(119%) | strlen(74%)

config(depth=4, elements=30, strlen=999):
serialize : time(0.018), length(30238)
json      : time(0.095), length(28817)
diff: time(521%) | strlen(95%)

Conclusión:

Para datos que se deben serializar pero que únicamente van a ser accedidos por php, casi siempre será mejor usar la opción de serialize. Especialmente con variables que contendrán cadenas muy largas.
Si se requiere acceder a esos datos desde otros lenguajes o modificarlos manualmente, json es una buena opción. Si se van a serializar objetos complejos, json será siempre más compacto. Si la variable contendrá una cadena, o indirectamente alguna cadena, como elemento o clave de un array y son cadenas muy largas, json está penalizado.

Usando y extendiendo PDO (I)

2008-03-31T01:24:00.010+02:00

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

2008-03-31T01:04:00.011+02:00

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

2008-03-30T20:38:00.015+02:00

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

2008-03-30T19:15:00.002+02:00

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.