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

Esta opción es la que permite escribir código php tal que <?=”algo”?>  en vez de tener que escribirlo como <?php echo “algo”?>. Vamos, algo MUY deseable desde mi punto de vista.

Creo que la gente de PHP ha metido un tanto la pata aquí, ya que todo viene por la ambiguedad al parsear documentos xml que empiezan con <?xml. En fin, lo voy a dejar, porque esta es otra historia.

Resulta que tengo una clase llamada jview que se encarga de manejar y cargar las vistas, y quería que se puedan seguir usando los short tags en esas vistas. Al final las vistas que maneja jview son templates PHP. Te puedes hacer una idea si piensas que al final es como un template en WordPress.

Por poner un ejemplo rápido, dado el siguiente código en PHP

<?php echo "hello"?> <?= "world"?>

Cuando short_open_tags está habilitado, la salida que produce PHP es:

hello world

Sin embargo si short_open_tags=”Off”, entonces PHP produce la siguiente salida:

hello <?= "world"?>

En fin, que tenía dos alternativas para solucionar mi problema:

• Copiar el archivo de vista que se intenta cargar a un fichero temporal, reemplazando los ‘<?=’ por ‘<?php ‘, ejecutando el fichero modificado, borrar el fichero
• Hacer un parser de código PHP en PHP que previamente reemplace los ‘<?=’ por ‘<?php ‘

Como uno es como es, he hecho el parser ;D

Lo mejor de todo es que han sido sólo 20 minutos!! Menos de lo que me esperaba!

Aquí está el código:

  function include_emulating_short_tags ($viewFile)
  {
    // Alternate method for making <?= valid
    $raw = file_get_contents ($viewFile);
    $raw = str_replace ('<?=', '<?php echo ', $raw); 
 
    $html = '';
    $phptokens = @token_get_all ($raw);
 
    $mode    = 'text';
    $phpcode = '';
    foreach ($phptokens as $ptoken)
    {
      if (($mode == 'text') && is_array ($ptoken) && ($ptoken[0] === T_OPEN_TAG)) {
        $mode = 'php';
        continue;
      }
 
      if (($mode == 'php') && is_array ($ptoken) && ($ptoken[0] === T_CLOSE_TAG)) {
        ob_start();
        eval ($phpcode . ';');
        $html .= ob_get_contents();
        ob_end_clean();
 
        $mode    = 'text';
        $phpcode = '';
        continue;
      }
 
      if ($mode == 'text') { 
        $html .= is_array ($ptoken) ? $ptoken[1] : $ptoken;
      }
      else {
        $phpcode .= is_array ($ptoken) ? $ptoken[1] : $ptoken;
      }
    }
 
    if (($mode == 'php') && ($phpcode !== '')) {
      ob_start();
      eval ($phpcode);
      $html .= ob_get_contents();
      ob_end_clean();
    }
 
    return $html;
  }

Al final, la variable $html que se devuelve, es la que contiene el supuesto código HTML que se mostraría.

Si hicieramos un include_emulating_short_tags con el código inicial y short_open_tags=0, seguiría saliendo “hello world”. El único inconveniente que le veo a esta forma, es que las variables de PHP tipo __FILE__, no sacarían el valor esperado. Aunque de todos modos esto tendría fácil arreglo, con otro str_replace

La verdad es que el plugin va de lujo, el único inconveniente que le veía desde hace ya tiempo es que los comentarios que la gente hiciera  en un idioma, eran visibles desde los demás idiomas. Esto no me parecía lógico, teniendo en cuenta que si tu entras a leer un blog en Inglés, si ves comentarios en Español, pues seguramente no te van a decir nada, e incluso más, es posible que hasta te bloqueen a la hora de dejar un comentario.

Como era algo que no me gustaba, ya le pedí hace tiempo a Anthony Petitbois, el creador original del plugin, a ver si podría incluir un par de mejoras en el plugin.

Como de eso hace ya cerca de 10 meses, y es algo que quería si o si para otro blog, pues pensé:

“Nunca he hecho ningún plugin de wordpress, pero no debe de ser muy complicado, sobretodo si cojo este como base”

Unas 4 horas y media más tarde, ya tenía el plugin actualizado en este blog, y después de las pruebas que he hecho, parece que todo funciona perfectamente, al menos para WordPress >= 2.8.x

Qué mejoras he incluido?

• zd_multilang_get_locale(): es una función que nos devuelve el idioma actual del blog (Inglés, Español, …)
• La posibilidad de mantener los comentarios separados para cada idioma
• La posibilidad de mantener un único hilo de comentarios, tal y como se hacía ahora

Nótese, que TODOS los comentarios previos a la instalación de esta actualización serán mostrados en TODOS los idiomas. No tiene sentido no mostrar comentarios si uno no sabe en qué idioma estan.

Nótese también que he añadido una opción para que el usuario pueda escoger cómo desea que se comporte el blog (manteniendo los comentarios separados, o manteniendolos todos juntos). Independientemente de la opción escogida, TODOS los comentarios son visibles desde el panel de administración, así se simplifica la administración de los comentarios

La única modificación que tendreis que hacer en vuestro site, para que esto funcione perfectamente, será en el theme que esteis usando, en el archivo comments.php, teneis que cambiar el formulario donde pone:

action=”<?php echo get_option(’siteurl’); ?>/wp-comments-post.php”

por

action=”<?php echo get_option(’siteurl’); ?>/wp-comments-post.php?lang=<?=zd_multilang_get_locale()?>“

Para concluir, en el siguiente enlace os podeis descargar el diff de los cambios con respecto a ZdMultilang 1.2.4, el archivo zdmultilang.php ya modificado, así como el readme.txt:

• Descargar ZdMultilang que mantiene los comentarios separados

Nótese que he incrementado el número de versión a la 1.2.5, sin embargo esto puede producir “problemas” futuros, a no ser que convenza a Anthony para que lo incluya en la siguiente versión

De momento, este parche no es oficial, pero es open source.

]]> http://www.codigomanso.com/es/2009/10/improved-multi-lingual-support-for-wordpress/feed/ 163 http://www.codigomanso.com/es/2009/06/detect-an-animated-gif-in-php/ http://www.codigomanso.com/es/2009/06/detect-an-animated-gif-in-php/#comments Sun, 28 Jun 2009 19:50:33 +0000 Pau Sanchez http://www.codigomanso.com/es/?p=679 La siguiente función sirve para detectar si un GIF es animado o no (tiene más de 1 frame).

  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:

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

Que son los ataques XSS (cross site scripting) y por qué hay que evitarlos es algo esencial que merece un post a parte.

La idea con la que hay que tienes que quedarte, es que si tienes o planeas realizar una página web donde permites que otros usuarios editen o publiquen contenido HTML (ya sea en forma de páginas, comentarios, etc…), debes de alguna manera validar que el contenido HTML que están generando es seguro.

Hay muchas librerias que se encargan de filtrar y validar estos contenidos HTML para asegurarse que la gente que sube contenidos no va a hacer nada malo. Yo por mi parte he estado mirando hace un rato, porque tampoco iba a ponerme a hacer la mía (no es mi objetivo en la vida  sacrificar dos semanas de trabajo si puedo usar algo que ya existe y funciona), y me he encontrado con HTML Purifier, una librería de PHP bastante extensa y con muchisima funcionalidad que se encarga de filtrar codigo maligno.

Utilizarla es muy muy sencillo. Sólo requiere dos lineas (una vez incluido el archivo base).

require_once '/path/to/htmlpurifier/library/HTMLPurifier.auto.php';
 
$purifier = new HTMLPurifier();
$clean_html = $purifier->purify($dirty_html);

Lo bueno de esta libreria, es que se pueden configurar muchisimas cosas, como limitar el número de tags, los atributos por tag, etc… e incluso es capaz de reformatear código html inválido y convertirlo en código válido (tal y como pueden hacen otras librerias como BeautifulSoup en Python o como Tidy HTML para C/C++)

También cabe destacar que en principio esta libreria NO REFORMATEA el código HTML, simplemente se encarga de eliminar o reformatear las partes peligrosas o inválidas.

Seguramente en el futuro vuelva a hacer algún otro post sobre el tema, sin embargo, si teneis ocasion, recomiendo echarle un vistazo al libro Building scalable web sites de Cal Henderson. Aunque seguramente en la wikipedia y googleando un poco encontrareis bastante información.

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.

Este artículo trata sobre como cambiar el orden de un elemento dentro de una tabla, manteniendo el orden relativo de todos los demás elementos y actualizando únicamente un campo. Como esta descripcción es un poco densa, vayamos por partes.

Por simplificar el ejemplo, digamos que estoy haciendo un sitio web relacionado con el mundo del motor, y como todo sitio web que se precie, tengo una base de datos. En esa base de datos hay dos tablas, una tabla marcas y otra tabla modelos. En la tabla marcas hay una fila por cada marca de coches (Toyota, Honda, Hyunday, Mercedes, Chrysler, BMW, Audi, …), y en la tabla de modelos de coches, pues hay una serie de modelos para cada tipo de coche. Por ejemplo, para Audi, estaría el modelo A6 2.0 TDIe , A5 2.0 TDI, A4, TT …, y la lista sigue hasta donde uno quiera y más para cada marca. Creo que con esto uno ya se hace una idea de las tablas que hay.

El tema es que en mi sitio web, yo quiero que cuando el usuario haga click en una marca, le salga una lista ordenada de los modelos disponibles para esa marca, pero no quiero un orden cualquiera, no quiero que salgan ni por nombre, ni por votos, ni por precio, quiero que por defecto salga por el orden específico que yo haya definido.

Pensareis, pues fácil, simplemente hay que añadir un campo orden dentro de la tabla modelos, o si os gusta tener las tablas normalizadas al máximo, pues creariais una tabla extra donde meteriais dos claves ajenas, una a modelos y otra a marcas y luego pondriais el campo orden.

Se haga de la forma A o de la forma B, el concepto final es que hay un campo que se llama orden, y que para lo que me sirve es para definir manualmente el orden en el que quiero que salgan los modelos en la página principal.

Hasta aquí sólo es introducción al artículo, lo bueno viene ahora.

Imaginad que en marcas sólo está Audi (por decir una), y que sólo hay 4 modelos en la base de datos A3, A4, A5 y TT. A partir de aquí vamos a hacer como si las marcas no existieran (por simplificar aún más). Así que se nos queda una tabla de modelos como sigue:

Ahora, si yo en mi sitio web, hago un select, y ordeno por el campo orden, pues como es lógico, viendo esa tabla, primero saldrá el A3, luego el A4, luego el A5 y seguidamente el Audi TT.

El problema:

¿Cómo hago ahora, si quiero que el Audi TT salga el primero?

Se debe tener en cuenta, que yo sólo quiero mover el Audi TT a la primera posición, pero quiero que el A3, A4 y A5 no cambien su orden relativo. Y he dicho la primera posición por decir algo, pero también podría querer que el TT apareciera entre el A3 y el A4.

Solución 1: la fácil

Bueno, pues lo primero que a uno le viene a la cabeza (al menos a mi), es básicamente incrementar en 1 todos los campos cuyo orden sea mayor al que yo voy a poner para TT, y luego actualizar el orden del TT.

UPDATE modelo SET ORDER = ORDER + 1 WHERE ORDER >= 1;
UPDATE modelo SET ORDER = 1 WHERE name = 'TT';

Básicamente arriba he utilizado 2 queries, uno de complejidad lineal que modifica una ristra de filas, y otro que sólo toca una tabla.

Como esta solución no me convencía demasiado, no era muy bonita, pues me puse a pensar y se me ocurrió otra.

Solución 2: la magia de los float

¿Y si en vez de un entero, se usa un número real?

Si el campo orden fuera real, entonces podría saber cual es el orden de los elementos inmediatamente anterior y posterior (puesto que los he cargado en el interfaz de usuario de mi web), y podría actualizar sólo el campo del TT sin tocar ningún otro elemento de la tabla.

Es decir, si tenemos la configuración inicial (A3, A4, A5, TT), y quiero que el TT esté entre A3 y A4, como A3 tiene el valor de orden igual a 1.0, y A4 tiene el valor de orden de 2.0, y quiero que TT esté enmedio, el tema quedará de la siguiente manera.

Básicamente lo que he hecho es calcular el valor intermedio entre A3 y A4, vease (1.0 + 2.0) / 2

Nótese que esto se puede hacer tantas veces como se quiera, que siempre habrá un orden entre los elementos y “jamás” habrá dos elementos con el mismo orden. Por ejemplo, si ahora quermos que el A4 esté entre el A3 y el TT, actualizaríamos el orden de A4 a (1.0 + 1.5)/2 = 1.25.

Como veis, el procedimiento está chupado, y sólo hay que tocar un campo.

Claro, ahora surgen varias preguntas. Me direis, que bonito, ¿y que pasa si quieres ponerlo en la primera posición? Fácil, si desde el principio se asume que el orden de los elementos que insertamos empieza en 1.0, entonces el elemento posterior será el que ya exista en la base de datos, y el elemento anterior será cero (0.0)

¿Y que pasa si ahora quieres insertar el A6? Pues pasa que si hay 4 elementos, el A6 habrá que insertarlo con el valor 5.0 (nunca habrá colisión si se hace como número de elementos + 1).

Y la pregunta estrella es: “oye, los números de punto flotante tenían un límite, ¿no? ¿que pasa si se desbordan?” Ah, amigo Sancho ¡Con la iglesia hemos topado!

Si os fijais, hacer que se desborde es tan fácil como ir moviendo todos los elementos siempre a la misma posición. Por ejemplo, si está el orden 1 y 2 inicialmente, y movemos el 3 a la segunda posición, ahora será 1, 1.5 y 2, luego si movemos el 2 a la segunda posición será 1, 1.25 y 1.5, si volvemos a mover el 1.5 a la segunda posición será 1, 1.125 y 1.25, y así sucesivamente hasta que el punto flotante diga hasta aquí (que puede ser mas o menos despues de unas 20 veces, según el número de bits que se usen para decimales).

Lo cual nos lleva a la solución 3

Solución 3: tapando agujeros

Solución 3.1: proceso en background

Una solución podría ser tener un proceso que una vez al día, a la semana o al mes, actualice todos los elementos de la tabla a números enteros respetando su orden actual. Aunque para eso casi mejor implementar la solución 1 que es más mantenible. Lo cual nos lleva a buscar otra alternativa.

Solución 3.2: actualización entera

Básicamente es igual que la solución 2 (no me repetiré), pero con una salvedad, y es que cuando se mueva un elemento a una posición, si no hay ningún número entero en esa posición se tratará de redondear al número entero hacia abajo (o hacia arriba, o ambos), para mitigar esa degradación de los flotantes que van teniendo cada vez más decimales.

Vease un ejemplo. Imaginemos que el tema se ha degradado un poco y parto de la siguiente configuración:

Si ahora muevo el A3, entre el A4 y el A5, de normal haría lo siguiente: (1.7628 + 3.78)/2 = 2.7714. Pero oh magia, si redondeo el 2.7714 hacia abajo me da 2, y resulta que el sigue estando entre 1.7628 y 3.78, por lo tanto en vez de actualizar a 2.7714 actualizaría a 2. De esta manera, si más tarde moviera el TT entre el A3 y el A5, en vez de hacer esta operación (2.7714 + 3.78) / 2, tendría que hacer esta (2 + 3.78) / 2, que obviamente tiene menos decimales.

Nótese que para esta solución símplemente hay que mirar si el número entero sigue estando entre el número anterior y el posterior (que son conocidos) y no es igual a ninguno de ambos.

Además, si se asume que movimiento de los elementos se hará de forma aleatoria, de esta manera es poco probable (aunque sigue siendo posible) que al final el punto flotante se desborde.

Por cierto, esta solución ahora mismo la he presentado con números reales, pero se pueden usar perfectamente números enteros, aunque siguiendo otro esquema.

Conclusión

Si quieres robustez, usa la solución 1 para mantener el orden de todos los elementos; si quieres actualizar un único elemento cada vez, porque es una operación que se va a realizar miles de veces por miles de personas al día lo recomendable es la solución 3.2, aunque tendría problemas si hay varias personas concurrentemente actualizando campos.

Finalmente, aunque en el artículo se han visto un par de soluciones (con sus parches), me encantaría saber si alguien conoce otras soluciones o sabe que problemas tienen en la práctica las que yo he puesto.

El caso es que después de 20 minutos he descubierto un bug en una web en PHP que estoy haciendo, y cuando me he dado cuenta de que era un problema de concepto de lo que se supone que hace la función “empty” y lo que realmente hace (tal y como dice en la especificación), pues me he dicho, ui, va a ser que es un bug, pero la implementación de empty no debería ser la que es. No es que quiera llevar la razón en todo, y pensar que los bugs no son culpa mía, obviamente lo son, incluso este, pero hay que tener en cuenta que cuando reconozco que un bug es mi culpa no hago un post sobre ello.

A ver, el caso es el siguiente, en un sitio remoto tenía un condicional, en plan si empty ($str) haz X, y si no es empty, pues haz Y. Fácil.

El problema conceptual viene en que según el manual de PHP: empty(“0″) es true!!

Por el amor de Dios! ¿en que estaría pensando el programador que hizo eso?

No lo digo por decir, lo digo porque no es muy consecuente con la definición del propio manual:

empty — Determine whether a variable is empty

The following things are considered to be empty:

• “” (an empty string)
• 0 (0 as an integer)
• “0″ (0 as a string)
• NULL
• FALSE
• array() (an empty array)
• var $var; (a variable declared, but without a value in a class)

Entiendo entonces, que una variable NULL se considere como vacía, que un array() se considere como vacio, que la cadena ” se considere como vacía, que el valor FALSE se considere como vacío. Incluso entiendo que el número 0 se considere como vacío. Hasta aquí tiene sentido, tiene sentido que cada tipo de datos (booleano, cadena, array, referencia) tenga un único valor que se considere como vacío.

Lo que no entiendo es porqué las cadenas tienen dos valores que se consideran vacías, una cadena vacía es ” y ya está.

Imagino que la explicación de por qué “0″ es considerado como vacío viene a ser porque en PHP puedes hacer 322 + “17″ e internamente transforma la cadena “17″ en el número 17 y hace la suma numérica. Siguiendo esta premisa, cuando empty recive “0″ a priori no se puede diferenciar si el programador está pasando una cadena porque quiere o el programador pretendía pasar el número 0 pero se le ha olvidado hacer un cast a int.

Conclusión: la función empty debería devolver false con ‘0′, pues asumir que el programador puede estar queriendo pasar 0 en vez de “0″ es imponer una restricción al programador, se le debería dejar que hiciera un cast si es que es un número lo que está evaluando con el empty, al no hacerlo lo que se consigue es que paguen justos por pecadores… argh!!!!

El problema es que a mi no me gusta lo que hace el navegador con los “checkboxes”.

Como cualquier otro input, los checkboxes tienen un valor asociado (por defecto “on”, aunque no estoy seguro de si esto varía según el navegador). Lo que uno esperaría de value, es que sea “on” si está checked y “off” si está unchecked. Pero no señores, no se confundan, siempre es “on”, igual que si le dices que value=”pepito”, value siempre será “pepito” independientemente de si el checkbox está checkeado o no.

Entonces (se preguntará el lector avispado que aún no haya tenido el placer de programar en HTML), ¿como sabe el servidor si el checkbox está checked o unchecked? Elemental mi querido Watson. El navegador sólo envia esa información si está checked y no la envia si está unchecked. ¿Que putada, no? Porque hay veces que parece que esto rompe algunos flujos típicos con otros datos.

No es que este comportamiento de los navegadores sea muy problematico, pero a veces a uno le interesa que funcione de otra manera.

Sea como fuere, aquí pongo una extensión para jQuery, que básicamente lo que hace es lo mismo que “serialize” pero pone siempre los checkboxes, de tal forma que pone “nombre=1” cuando el checkbox está activado, y “nombre=0” cuando no está activado.

jQuery.fn.jserialize = function () {
  var serialized = this.serialize();
 
  $(this).find(':checkbox').each (function() {
    var tofind    = $(this).attr('name') + "=" + $(this).val();
    var toreplace = $(this).attr('name') + "=" + (this.checked ? '1' : '0');
 
    if (this.checked)   { serialized = serialized.replace (tofind, toreplace); }
    else                { serialized += "&" + toreplace; }
  });
 
  return serialized;
}

Enlaces de interés:

• Resetear un formulario con jQuery
• Pregunta de Badtant sobre porque serialize no envia los unchecked checkboxes
• Página oficial de jQuery
• Método jQuery.serialize
• Método jQuery.serializeArray