##
# Mimics the behaviour of http_build_query PHP function
# This method can be useful for sending data to flash applications
##################################################
def http_build_query(params, topkey = ''):
  from urllib import quote

  if len(params) == 0:
    return ""

  result = ""

  # is a dictionary?
  if type (params) is dict:
    for key in params.keys():
      newkey = quote (key)
      if topkey != '':
        newkey = topkey + quote('[' + key + ']')

      if type(params[key]) is dict:
        result += http_build_query (params[key], newkey)

      elif type(params[key]) is list:
        i = 0
        for val in params[key]:
          result += newkey + quote('[' + str(i) + ']') + "=" + quote(str(val)) + "&"
          i = i + 1

      # boolean should have special treatment as well
      elif type(params[key]) is bool:
        result += newkey + "=" + quote (str(int(params[key]))) + "&"

      # assume string (integers and floats work well)
      else:
        result += newkey + "=" + quote (str(params[key])) + "&"

  # remove the last '&'
  if (result) and (topkey == '') and (result[-1] == '&'):
    result = result[:-1]

  return result

Suponiendo que te hace falta, hay dos formas de saber el sistema operativo. La primera, y más completa, es mediante la función php_uname. La función php_uname es similar al comando uname de linux, y con esta podemos saber el sistema operativo y la versión del mismo, el número de release del SO, el nombre del host y la arquitectura del ordenador. Completito completito.

Por otra parte, si no queremos calentarnos la cabeza, y sólo queremos saber el sistema operativo, se puede usar la constante PHP_OS. Más sencillo, pero en la mayoría de los casos será suficiente (el equivalente sería php_uname(’s’)).

echo php_uname() . "\n";
echo PHP_OS . "\n";

Lo primero que me vino a la cabeza fué la extensión de PDFlib que incluye PHP desde la versión 4. El problema de esta versión es que me parecía muy a bajo nivel, y tampoco tenía ni idea de por donde empezar.

La lista de funciones de PDFlib que incorpora PHP es bastante extensa, y seguramente se puede hacer de todo, pero no quería estar escribiendo cientos de lineas para hacer una chorrada de PDF, símplemente quería ponerle un fondo y escribir cuatro cosas.

En fin, que buscando más información, acabé encontrándome con la librería TCPDF que parecía muchísimo más completa, y más sencilla de usar. Realmente no se si es más sencilla o no, porque al final no he hecho nada con la extensión de PDFlib, pero TCPDF tiene muchos ejemplos. Hay ejemplos supersencillos de muchas cosas, con lo que hacer un PDF se convierte prácticamente en copiar y pegar de aquí y allá.

La verdad es que con esta librería hice un prototipo de lo que quería hacer en 15 minutos. Puedes pasarle el código en formato HTML y luego la librería lo formatea internamente en el documento. Esto hace que no te tengas que calentar mucho la cabeza.

La única “pega” que le veo, es que ocupa unos 10MB comprimida en zip, lo que son unos 16 megas una vez descomprimida.  En cualquier caso, la mayor parte del tamaño no es por la librería en sí, si no por que dentro lleva ya fuentes tipográficas, la documentación, y ejemplos. Si eliminamos las fuentes que no nos hacen falta y la documentación, se puede quedar en poco más de 1 megabyte descomprimida. Vamos, de lujo.

Más información sobre esta librería en www.tcpdf.org

el GOTO

Resulta increible cómo puede ser que introduzcan en PHP cosas de tan alto nivel, y de tan bajo nivel a la vez… deben de haber tenido bastante presión por parte de la gente, porque sino no me lo explico…

En la documentación de PHP del goto se puede ver que las cosas se las toman con humor:

  function isAnimatedGif($filename)
  {
    $filecontents=file_get_contents($filename);

    $str_loc=0;
    $count=0;

    # There is no point in continuing after we find a 2nd frame
    while ($count < 2)
    {
      $where1=strpos($filecontents,"\x00\x21\xF9\x04", $str_loc);
      if ($where1 === FALSE) {
        break;
      }

      $str_loc = $where1+1;
      $where2  = strpos($filecontents,"\x00\x2C",$str_loc);
      if ($where2 === FALSE) {
        break;
      }
      else {
        if ($where1+8 == $where2) {
          $count++;
        }
        $str_loc = $where2+1;
      }
    }

    // gif is animated when it has two or more frames
    return ($count >= 2);
  }

También está la siguiente alternativa, más compacta que la anterior:
<pre>
function isAnimatedGif($filename) {
return (bool)preg_match('#(\x00\x21\xF9\x04.{4}\x00\x2C.*){2,}#s', file_get_contents($filename));
}

El código lo he modificado minimamente a partir de lo que he encontrado en los comentarios de http://es2.php.net/manual/en/function.imagecreatefromgif.php

Hoy día hay cientos de librerias para cualquier lenguaje que realizan un escalado. La única pregunta es, ¿cuales deben ser el nuevo ancho y largo de la imagen?

A continuación el código mágico que está probado en javascript, pero que debe funcionar en PHP, python, java, perl, C, y lo que le pongas por delate

if (w < h) {
  h = (h * maxWidth) / w;
  w = maxWidth;
}
else {
  w = (w * maxHeight) / h;
  h = maxHeight;
}

w representa el ancho o width de la imagen

h representa el alto o height de la imagen

maxWidth la anchura máxima del área en la que se quiere meter la imagen

maxHeight la altura máxima del área en la que se quiere meter la imagen

Como ejemplo final, aunque es prácticamente copy paste, imaginad que quereis meter una imágen de tamaño (w, h) en un área de 640×480:

var maxWidth = 640, maxHeight = 480;
if (w > maxWidth || h > maxHeight) {
  if (w < h) {
    h = (h * maxWidth) / w;
    w = maxWidth;
  }
  else {
    w = (w * maxHeight) / h;
    h = maxHeight;
  }
}

Creo que próximamente compartiré la clase de manejo de cadenas que estoy desarrollando, y que soporta 100% utf-8.

De momento voy a compartir una función, que si bien no es la más aconsejable puesto que los arrays en PHP consumen MUCHOS recursos, creo que facilita el uso de cadenas UTF-8, pues se les puede dar el mismo tratamiento que a una cadena normal.

Convertir una cadena UTF-8 a un array tiene 2 grandes ventajas:

• cada elemento del array representa un único caracter
• count sobre el array será equivalente a mb_strlen sobre la cadena

La gran destventaja son los tiempos de conversión y el consumo de memoria, al estar usando un array.

Ayer básicamente programé 2 funciones y cojí prestado un ejemplo que había puesto un usuario en la documentación de PHP.

Las tres versiones de estas funciones las podeis ver a continuación:

function getCharArray1 ($jstring)
{
  $len = mb_strlen ($jstring, 'UTF-8');
  if (mb_strlen ($jstring, 'UTF-8') == 0)
    return array();

  $ret = array();
  for ($i = 0; $i < $len; $i++) {
    $char = mb_substr ($jstring, $i, 1, 'UTF-8');
    array_push ($ret, $char);
  }

  return $ret;
}

// code from: http://uk3.php.net/manual/en/function.mb-split.php#80046
function getCharArray2 ($jstring)
{
  $len = mb_strlen ($jstring, 'UTF-8');
  if (mb_strlen ($jstring, 'UTF-8') == 0)
    return array();

  while ($len) {
    $ret[]  = mb_substr($jstring,0,1,"UTF-8");
    $jstring = mb_substr($jstring,1,$len,"UTF-8");
    $len = mb_strlen($jstring);
  }
  return $ret;
}

// using mb_check_encoding instead of mb_substr 
function getCharArray3 ($jstring)
{
  if (mb_strlen ($jstring, 'UTF-8') == 0)
    return array();

  $ret  = array ();
  $alen = strlen ($jstring);
  $char = '';
  for ($i = 0; $i < $alen; $i++) {
    $char .= $jstring[$i];
    if (mb_check_encoding ($char, 'UTF-8')) {
      array_push ($ret, $char);
      $char = '';
    }
  }

  return $ret;
}

La función más rápida es la última, que utiliza un pequeño truco que se me ocurrió.

La gráfica representa los tiempos de ejecución de cada una de estas funciones para una serie de iteraciones sobre una cadena notablemente larga.

Leyenda:

• getCharArray1: en rojo
• getCharArray2: en verde
• getCharArray3: en azul

Como se puede comprobar, getCharArray3 es la más rápida (sobre 4x más que getCharArray1 y 6x más que getCharArray2).

Finalmente, aquí teneis el enlace al script de benchmark que he usado para obtener esa gráfica.

El caso es que para algunos de los componentes necesitaba hacer un parser (también llamado analizador sintáctico), y para el parser necesitaba un tokenizador en PHP (tokenizador = analizador léxico o lexer), y claro está, cuanto más rápido funcione todo mejor (que PHP es interpretado y ya se sabe).

Total, que había dos opciones: o hacerlo desde 0, usando las funciones de string que trae PHP (una opción que se plantea lenta); o bien usar la función token_get_all que está disponible desde la versión 4.2.0.

Personalmente, he preferido usar token_get_all, aunque esta funcion sea, en si misma, un parser de código de PHP. Lo que he hecho es una clase que encapsula la llamada a esta función y devuelve una lista de token ids vs texto.

El truco para llamar a token_get_all es añadir “<?php “ y “?>” al principio y final de la cadena que se desea tokenizar (probablemente el “?>” del final no haga falta).

Si los tokens necesarios para el parser es un subconjunto de los tokens que soporta PHP, entonces no hay ningún problema con usar este método, si no es así, habrá que currarselo un poco más (y como en mi caso sí se trata de un subconjunto, dejo ese tema zanjado en este punto).

El problema de la función token_get_all es que devuelve un array no demasiado normalizado. A veces devuelve un único item (el texto propio del token), mientras que otras veces devuelve un par de elementos en un array (el primero es el token id y el segundo el texto).

Al tema:

class jtokenizer {
  const TK_UNKNOWN  = 0x0000;
  const TK_ID       = 0x0001;
  const TK_STRING   = 0x0002;

  const TK_PLUS     = 0x0003;
  const TK_MINUS    = 0x0004;

  // ...

  public static function tokenize ($string) {
    $tokens = array();
    $phptokens = token_get_all ('<?php ' . $string . '?>');

    foreach ($phptokens as $ptoken) {
      $id = self::TK_UNKNOWN;
      if (is_string ($ptoken)) {
        $text = $ptoken;
        switch ($ptoken) {
          case '+': $id = self::TK_PLUS;  break;
          case '-': $id = self::TK_MINUS; break;

          ////////////////////////////////////////
          // Add more tokens here!
          // E.g: '.', ',', ';', ':', '=', ...
          ////////////////////////////////////////

          default: /** handle error here! */ break;
        }
      }
      else { // this should be an array (tokenid, text)
        list ($tokenid, $text) = $ptoken;
        switch ($tokenid) {
          // ignore opening/closing tag
          case T_OPEN_TAG:   $id = NULL; break;
          case T_CLOSE_TAG:  $id = NULL; break;

          // ignore white spaces
          case T_WHITESPACE: $id = NULL; break;

          case T_CONSTANT_ENCAPSED_STRING:
            $id = self::TK_STRING;
            // remove ' or " at the beginning and at the end
            $text = trim($text, $text[0]);
            break;

          case T_STRING:
            $id = self::TK_ID;
            break;

          ///////////////////////////////////////////
          // Add more tokens here!
          // Get a complete list from:
          // http://uk3.php.net/manual/en/tokens.php
          ///////////////////////////////////////////

          default: /** handle error here! */ break;
        }
      }

      // append the token
      if ($id !== NULL) {
        array_push ($tokens, array ($id, $text));
      }
    }

    return $tokens;
  }
}

Básicamente esto es un esqueleto que podría servir para ejemplificar un poco cómo hacer el parser, aunque faltarían muchas cosas que añadir. Luego tokenizar una cadena sería simplemente hacer una llamada a jtokenizer::tokenize ($string).

En el array devuelto por esta nueva función estarán normalizados todos los tokens con nuestros propios identificadores. Por lo que si nos llega un jtokenizer::T_STRING, sabremos que es un string, y en la posición 1 del array estará el propio texto de la cadena. Y lo mismo si nos llega un jtokenizer::T_PLUS.

Creo que con este ejemplo ya es suficiente para que alguien interesado en el tema pueda hacerse el suyo propio, y si no le gusta devolver un array de arrays de 2 elementos, pues puede devolver lo que quiera :p

Para más información, me remito a la documentación de PHP:

• Función token_get_all en php.net
• Tokenizador de PHP
• Lista de tokens devuelta por token_get_all

Nota: Si se queire que sea aún más rápido es mejor usar arrays asociativos en vez de switches

¿Alguien ve algo raro en el siguiente código?

for ($i = 0; $i < strlen ($string); $i++) {
    // whatever this loop does
}

A priori ¿Parece que todo está bien, no? Si te lo parece es que no eres consciente aún.

Es bien sabido que las condiciones de los bucles se evaluan tantas veces como iteraciones tiene el bucle, con esto no estoy descubriendo nada a nadie, sin embargo, si se mete un strlen para medir la longitud de la cadena en un bucle que se ejecuta tantas veces como caracteres hay, acabamos de elevar al cuadrado el tiempo de ejecución.

Tanto en C como en PHP, la función strlen necesita recorrer toda la cadena hasta encontrar el ‘\0′ para determinar su longitud, así pues, si la longitud es 20, strlen necesitará 20 iteraciones para determinar que la longitud es 20. El problema es que el bucle que estamos haciendo también tiene 20 iteraciones, y en cada iteración se ejecuta strlen, que consume otras 20 iteraciones (claro que en PHP esas 20 iteraciones se ejecutan en código máquina, y no en el interprete), por lo que tendríamos que el coste de ese bucle para una cadena de 20 caracteres es de 20*(20 + lo que hay dentro del bucle) = 400 + 20*lo que hay dentro del bucle.

El siguiente script (error común con los bucles) muestra un ejemplo de esto en PHP, donde dentro del bucle no se hace nada, y se puede observar como un bucle es mucho más lento que el otro.

Los resultados tras ejecutarlo en mi ordenador han sido:

strlen($sentence) =  12608 bytes
Making the common mistake: 3.02566313744 seconds
Fixing the common mistake: 0.958508968353 seconds

Creo que se puede apreciar claramente la diferencia

Finalmente, aunque he usado PHP para ilustrar el error, y concretamente strlen, si nos olvidamos de strlen y de PHP, esto es aplicable a otros muchos lenguages C/C++/Java/Pascal/PHP/Python/Perl/Ruby y un largo etcetera; y pasa en todos los lenguajes porque todos los lenguajes usan el mismo concepto, la condicion de salida del bucle se evalua en cada iteración. Quizás no ocurra cuando se utilizan cadenas, porque guardan la longitud en una variable, pero puede que pase al mirar la longitud de listas enlazadas, etc…

Conclusión: si en el bucle estás llamando a una función que siempre te va a devolver lo mismo, mejor guardalo en una variable y usa esa variable dentro del bucle, te ahorrará sorpresas

Enlaces interesantes:

• Back to basics, un excelente artículo de Joel (disponible en Español) donde reflexiona sobre algunas cosas directamente relacionadas con esto.

La diferencia entre tener un array asociativo (o mapa/diccionario/…), y una mera lista de elementos, es que no hay claves para acceder a los valores.

Básicamente, la diferencia expresada en código sería:

$asociativo = array ("key1" => "value1", "key2" => "value2", "keyN" => "valueN");
$lista      = array ("value1", "value2", "valueN");

Aunque uno pueda pensar que es sencillo saber si un array es un diccionario o es una lista, no existe ninguna función en PHP (al menos no la he encontrado), que te de esta información. Y programarlo no es demasiado complicado, pero tampoco se hace en 2 minutos.

A continuación, para el que le interese, pongo las funciones is_list y is_dict que básicamente nos dicen si un array es una lista o un diccionario (con sólo una llamada podremos diferenciarlos):

function is_list ($array)
{
    if (!is_array ($array))
      return false;

    $keys = array_keys ($array);
    foreach ($keys as $key) {
        if (!is_numeric ($key))
            return false;
    }
    return true;
}

function is_dict ($array) {
    return is_array ($array) && !is_list ($array);
}

Y como ejemplo, tras ejecutar el siguiente código:

echo "asociativo: " . (is_dict ($asociativo) ? "DICCIONARIO!" : "No diccionario...");
echo "lista: " . (is_dict ($lista) ? "DICCIONARIO!" : "No diccionario...");
echo "\n";
echo "asociativo: " . (is_list ($asociativo) ? "LISTA!" : "No lista...");
echo "lista: " . (is_list ($lista) ? "LISTA!" : "No lista...");

Se obtiene como salida:

asociativo: DICCIONARIO!
lista: No diccionario...

asociativo: No lista...
lista: LISTA!

Que es justo lo que queremos

Y aquí, el enlace con el ejemplo y las funciones para validar en PHP si un array es una lista o un diccionario.