Aunque no pretendo arreglarle la vida a todo el mundo, en este post sí les dejaré algunos tips para asegurarse de que todo funciona como debería: se verán algunas funciones de PHP que sirven harto y se verá superficialmente la interacción con bases de datos.
Dato rosa antes de continuar: la diferencia entre acento y tilde, es que tilde representa el signo " ´ " mientras que acento se refiere a la fuerza que se le impregna a la sílaba específica. De esta manera, en la palabra "sílaba", el tilde está en la letra "i", mientras que el acento está en la sílaba "sí".

Barniz teórico

Los charset no son más que códigos mediante los cuales el computador guarda de forma binaria la representación de un caracter que nosotros podamos entender y comprender.
De esta manera, el computador no entiende lo que significa la letra "A", pero sí conoce cómo trabajar con el número hexadecimal 65, representación de "A".
Es en esta última etapa donde está el problema: las codificaciones disponibles por razones históricas no son las mismas, por lo que en un charset determinado, la letra "A" podría estar representada por el número 190 y en otro por el 65.

Volviendo un poco a la realidad actual, hoy en día tenemos 2 codificaciones que son las más populares: la ISO-8859-1 y UTF-8. Aunque en sus primeros 127 caracteres son iguales, a partir de ahí la cosa cambia, aunque no mucho.
Sin embargo, para la desgracia de los hispano-hablantes, cada letra que nos hace distinto al inglés, tiene una codificación distinta. Esto quiere decir que justamente las letras con tildes son aquellas que confundiéndolos de codificación, no vamos a poder entender y nos aparecen todo tipo de caracteres extraños, un signo de pregunta en caso de querer imprimir la letra "á" de ISO-8859-1 en una codificación UTF-8 y dos símbolos extraños (dos debido a que UTF-8 guarda la letra "á" en dos bytes en vez de uno) en caso de querer ver "á" codificado en UTF-8 en una codificación ISO-8859-1. Suena un poco enredado, pero tiene su lógica.

Empezando a solucionar el problema

Desde que comprendí el esquema de trabajo, es que empecé a ser constante, y es lo más importante sin duda. Sucede que las codificaciones están en todos lados: desde el archivo mismo con el que uno trabaja hasta la consulta que la DB devuelve.
Para esto, primero debemos aclarar con cuál charset nos quedamos. Por opción personal, prefiero UTF-8 debido a que es más nuevo y más compatible a nivel global, no importando el sistema operativo. Un Linux instalado en China con sólo lo mínimo, es probable que no entienda la codificación ISO-8859-1 que es la latinoamericana, pero sí va a tener UTF-8 instalada.

Partiendo por esto, es que debemos asegurarnos en primer lugar que los archivos que creemos estén codificadas bajo UTF-8. En Linux, el cambio es fácil de hacer gracias a iconv, basta hacer un
iconv -f ISO-8859-1 -t UTF-8 -o salida.txt entrada.txt
para convertir uno (o más) archivos desde ISO-8859-1 a UTF-8. En Windows el asunto se pone un poco más complejo: el único método que sé que funciona es bajando PSPad y haciendo la conversión desde dentro del programa. Puede que exista una forma más fácil, pero no tengo ningún Windows a mano en este momento como para ponerme a averiguar.

Después de los archivos le toca a la base de datos. Ojo que en MySQL, la codificación UTF-8 no existe! Sólo existe utf8 (en minúsculas sin raya) y por supuesto latin1, que sería el equivalente a ISO-8859-1. Obviamente existen muchas codificaciones más, las que pueden ver aquí.
Por lo general a MySQL le importa poco y nada el charset con el cual guarda los datos, sólo le importa el charset con el que entrega los datos, así que con decirle que trate todos los datos salientes en esa conexión como UTF-8 debería ser suficiente. ¿No sabe cómo? Ocupe mi class
Si estás ocupando otro motor, ya depende de cada uno. En PostGreSQL por ejemplo, se define el charset cuando se crea la base de datos (échenle un vistazo a este thread en CHW para saber cómo cambiar de uno a otro), mientras que en otros motores la cosa puede ser un poco más difícil. De todas maneras, siempre debería ser posible poder cambiar el charset.

Finalmente, está la salida hacia el navegador.
Aunque por lo general el navegador podrá averiguar por si solo el charset del documento (Apache tomará el control), hay veces que tanto Apache o el navegador no sabrán qué codificación aplicar. Para evitar estos errores, se debe usar PHP para señalar qué charset se ocupará en el documento, lo cual es algo que veremos en el próximo capítulo.

Funciones útiles de PHP

Algunas funciones muy útiles de PHP son sin duda el poderoso iconv() y en menor medida utf8_encode() y utf8_decode(). También sirven de utilidad htmlentities() (que por supuesto tiene su inversa html_entity_decode()) y su casi simil htmlspecialchars(). Por supuesto que también es importante la función header(), ya que sin ella Apache asumirá el control, lo cual obviamente no es la idea.
Existen otras funciones que hacen cosas parecidas o que extienden las funcionalidades, pero jamás las he ocupado y para casi cualquier operación que se quiera hacer, con el uso de estas funciones uno está más que bien.

Pero qué se puede hacer con estas funciones? Básicamente, convertir de un formato a otro.
Aunque claramente están explicadas en el manual, haré un pequeño resumen acerca de qué es lo que hacen estas funciones:

iconv: Convierte de un charset a otro arbitrariamente. Ejemplo de uso:

$cadena = iconv('ISO-8859-1','UTF-8//TRANSLIT','cádéñá cón tíldés');

El primer parámetro es origen, segundo destino y le agregué TRANSLIT para que de esta manera, se "traduzca" la letra que no se conoce lo mejor posible. Esto podría llegar a pasar con algunos caracteres extraños.

utf8_encode y utf8_decode: Respectivamente, son sinónimos para:

iconv('ISO-8859-1','UTF-8//TRANSLIT','cádéñá cón tíldés');
iconv('UTF-8','ISO-8859-1//TRANSLIT','cádéñá cón tíldés');

htmlentities: Convierte todos los caracteres que tienen alguna equivalencia en entidad a su respectiva entidad. Sugiero leer la documentación oficial ya que es bien powa esta función.

html_entity_decode: Lo mismo que la anterior, pero al revés.

htmlspecialchars: Lo mismo que htmlentities pero sólo se aplica a los siguientes caracteres:
& => &
" => " (Sólo cuando ENT_NOQUOTES no se encuentra presente)
' => ' (Sólo cuando ENT_QUOTES está presente)
< => &lt;
> => &gt;

header: Permite mandar cabeceras al navegador. Lo más genial de esta función es que nos permite enviar el charset de la siguiente forma:

define('CHARSET','UTF-8');
header('Content-type: text/html; charset='.CHARSET);

Conclusiones

Para trabajar de una buena manera, recomiendo en muy resumidas cuentas:

Crea todos tus archivos bajo la codificación UTF-8
Mantén la base de datos (y por supuesto las tablas en el caso de MySQL) bajo la codificación UTF-8
Siempre señala en tu cabecera la codificación que irá a ocupar la página.

Espero que les haya servido el post. Intenté hacerlo lo más corto posible sin caer en hacerlo demasiado complicado.

$(document).ready(function(){$('a:not([href^="http://blog.unreal4u.com/"])').attr("target","_BLANK");});

Obviamente tiene que reemplazar http://blog.unreal4u.com/ con la ruta de su aplicación.

Sin embargo, el verdadero potencial de este post está por verse, veamos algunos comandos semi-avanzados de vim que nos hará la vida mucho más fácil al trabajar con este editor.

Lo primero, (y más importante) a mi gusto, es instalar el manual de PHP en vim. Para esto, debemos tener instalado man y pear. De ahí, se procede a la instalación del manual.

En CentOS, todo esto se haría como:

# yum install php-pear man
# pear install doc.php.net/pman

Y estaríamos con el 80% de la pega adelantada ya. Lo más importante, sin embargo, viene ahora.

Debemos, primero que nada, abrir el archivo ~/.vimrc. Si no existe, lo creamos. En ella, podemos configurar a nuestro gusto total vim, incluyendo opciones tan avanzadas como agrupar código (en una sola línea), poner el número de línea del código o consultar el manual de PHP con una tecla mientras estamos en la función. (Muy al estilo man).

Esta es mi configuración actual de vim:

set tabstop=2
set autoindent
set incsearch
set number
set keywordprg=pman
autocmd FileType php let php_folding=1
au BufWinLeave * mkview
au BufWinEnter * silent loadview

Explicaré cada línea:
set tabstop=2: Esto nos permite que, cuando apretemos tab, inserte espacios en vez de un tab. La cantidad de espacios es definida después del signo igual.
set autoindent: Esta muy útil función permite que vim siga las reglas de indentación que tiene el archivo. Muy útil.
set incsearch: permite que, muy al estilo búsqueda rápida de Firefox, se vaya ubicando automáticamente el cursor en cuanto estemos buscando alguna frase.
set number: le pone número a las líneas.
set keywordprg=pman: esta línea hace que integremos pman con vim, para que de esta manera, al apretar "K" (k mayúscula) sobre alguna función en específico aparezca el manual.
El resto: Activa la agrupación de código. La primera línea inicia la característica en sí, mientras que las dos siguientes guardan y cargan automáticamente las agrupaciones respectivamente.
Se debe utilizar en conjunto con algunos comandos:

:20,40 fo
Para agrupar de la línea 20 a la 40.
zfa}
Para agrupar de aquí a la próxima llave, aunque ojo: se debe estar posicionado sobre la llave que abre!
zd
Para eliminar el fold actual
zm
Para refoldear todos los folds anteriores.
Para más comandos útiles, visitar la tercera fuente.

Hay bastantes más consejos para vim, pero no todos me funcionaron. Una de las más populares que he visto dando vueltas por internet es activar la vista de código HTML o queries dentro de los string, pero no me funcionaron. Tampoco me funcionó desactivar los tags cortos, así que ojo con eso.

Fuentes:
PHPSLACKER
bjori doesn't blog
Linux.com

Sin embargo, hoy constituyen un pilar fundamental en mi ambiente de desarrollo, puesto que me permiten ejecutar código, y poder redirigir a alguna página en específico incluso después de haberse ejecutado la página completa. Por supuesto, también me permite insertar contenido Javascript en los headers después de haber ejecutado la página.

¿Pero cómo se ocupa? Para esto es este post.

Antes de poder imprimir código, debo explicar para qué sirve: ob_* controlan un buffer, el cual se puede controlar. La gracia es que la salida puede ser demorada por lo que podemos hacer cualquier acción, ya sea redirigir a otra página o -a mi gusto la más importante- poder controlar las cabeceras en cualquier momento, ideal para una carga por partes de la aplicación, sin caer en cargar partes que ni siquiera ocuparemos.

Existen específicamente 3 funciones que yo diría son las más importantes:

• ob_start(): que le da comienzo al buffer
• ob_flush(): que permite limpiar el buffer imprimiendo toda la salida
• ob_get_contents(): que permite obtener los contenidos del buffer sin imprimir en pantalla
• ob_end_clean(): que permite desechar todo el buffer, sin imprimir en pantalla

Dicho eso, podemos proceder a nuestro primer ejemplo:

ob_start();
echo 'hola mundo';
if (!file_exists('chao.txt')) header('Location: http://www.google.com/');
$contenido = ob_get_contents();
ob_end_clean();

include('cabecera.php');
echo $contenido;
include('pie-pagina.php');

Este archivo hace lo siguiente: Imprime "hola mundo", revisa si existe el archivo chao.txt y si no existe, redirige a Google. Si existe el archivo entonces sigue la carga normal. ¿Se entendió? Veamos un último ejemplo un poco más completo entonces:

index.php

include('carga-previa.php');
ob_start();
echo '<h1>Hola mundo</h1>';
if (!is_readable('chao.txt')) $msgStack->add('No se encontró el archivo!');
else $msgStack->add('Se encontró el archivo!');
$titulo = 'Hola mundo';
$contenido = ob_get_contents();
ob_end_clean();

include('cabecera.php');
echo $contenido;
include('pie-pagina.php');

carga-previa.php

class messages() {
  private $aMsgs = array();

  public function add($msg) {
    if (!empty($msg)) $this->aMsgs[] = '<h4 class="mensaje">'.$msg.'</h4>';
    return TRUE;
  }

  public function print() {
    if (count($this->aMsgs) > 0) {
      foreach($this->aMsgs AS $a) {
        echo $a;
      }
    }
    return TRUE;
  }
}

$msgStack = new messages();

cabecera.php

echo '<html><head><title>';
if (!empty($titulo)) echo $titulo;
else echo 'sin titulo';
echo '</title></head><body>';
$msgStack->print();

Ahora bien, no tiene ninguna gracia tener que escribir 20 líneas de código cuando nos podríamos ahorrar todo eso en un solo paso. Veamos nuevamente cómo podemos ahorrar bastante código y a la vez tener control absoluto sobre la aplicación:

index.php

include('carga-previa.php');
include('cabecera.php');
echo $contenido;
include('pie-pagina.php');

carga-previa.php

class messages() {
  // etc
}

if (empty($_GET['a'])) $_GET['a'] = 'index';
else $_GET['a'] = strtolower($_GET['a']);

$msgStack = new messages();
$myLink   = new DB_mysql();
// cargar otras classes

ob_start();
if (is_readable('includes/paginas/'.$_GET['a'].'.php')) include('includes/paginas/'.$_GET['a'].'.php');
else include('includes/paginas/not-found.php');
$contenido = ob_get_contents();
ob_end_clean();

Las demás páginas siguen tal cual como venían originalmente. Ahora lo único que debemos hacer para cargar por ejemplo las noticias es poner en nuestro navegador
www.ejemplo.com/?a=noticias o bien
www.ejemplo.com/?a=login
para cargar el login. Si a esto le sumamos un poco de htaccess, podemos cargar la página respectiva mediante
www.ejemplo.com/noticias/ o
www.ejemplo.com/login/.

En resumen: ob_* permite crear páginas con mucho poder de administración, fáciles y super rápidas de hacer en cuanto a desarrollo, de una forma elegante y cómoda.

Fuera de bromas, es un script bastante cortito (menor transferencia == página más rápida para el usuario) que realiza la verificación simple del RUT, es decir, un RUT tipo 11.111.111-1 seguirá siendo válido para este algoritmo. Lamentablemente el tiempo para hacer el completo no me sobra y creo que este blog es fiel reflejo de ello: hace muchísimo tiempo que no lo actualizo con alguna noticia.

También anda bastante lento el algoritmo en general, aunque eso puede ser problema de mi propio PC también. Sin embargo, se puede optimizar bastante más. La base fue tomada (la idea no más en realidad) del sitio del BancoEstado, específicamente este iframe. La versión de BancoEstado pesa 8309 bytes mientras que la versión realizada por mi pesa 1232 bytes (Un nada miserable 85% menos!). Manejando los mensajes de otra forma creo que se puede llegar al límite de un solo paquete de 1024 bytes.
A continuación, el algoritmo del RUT chileno en Javascript y en PHP.

Javascript

function ff(a){b=a;setTimeout("b.focus();",0);setTimeout("b.select();",0);return true;};
/* BORRAR COMENTARIO:: Lo de arriba es un arreglo para Firefox */
function revisa_RUT(c,e){
var t="";var b=0;var w=c.value;for(i=0;i<w.length;i++){if(w.charAt(i)!=' '&&w.charAt(i)!='.'&&w.charAt(i)!='-'){t=t+w.charAt(i)};};if(t.length==8){t=0+t;};
if(t.length!=9){return 'Lo sentimos, pero el RUT no corresponde. Por favor intente nuevamente.';};
if(e=='e'){b=1;};a=t.substring(t.length-1,-1);d=t.charAt(t.length-1);if(d=='k'){d='K';};
if(isNaN(a)){return 'Lo sentimos, pero el RUT contiene caracteres invalidos. Por favor intente nuevamente.';};
if(b==1&&a>50000000){return 'Lo sentimos, pero el RUT ingresado no corresponde a un RUT de persona natural.';};
//if(b==0&&a<50000000){return 'Lo sentimos, pero el RUT ingresado no corresponde a un RUT de empresa.';};
if(!revisa_DV(a,d)){return 'Lo sentimos, pero el RUT es incorrecto. Por favor intente nuevamente.';};
c.value=a.substring(0,2)+'.'+t.substring(2,5)+'.'+t.substring(5,8)+'-'+d;
return true;};
function revisa_DV(a,b){if(a==null||b==null){return false;};
var s=0;var m=2;var d='0';var e=0;
for(i=a.length-1;i>=0;i--){s=s+a.charAt(i)*m;if(m==7){m=2;}else{m++;};};
var r=s%11;if(r==1){d='K';}else{if(r==0){d='0'}else{e=11-r;d=e+'';};};
if(b!=d){return false;};return true;};
/*
Llamar:
onblur="javascript:g=revisa_RUT(this,'n');if(g!=true){alert(g);ff(this);};"

donde:
this == el elemento input del RUT
'e' == tipo de persona: natural o jurídica. "n" para natural, "e" para jurídica.

TODO:::
llamar a una función separada que dé el formato indicado.
Optimizar.
*/

PHP

function verifica_RUT($rut='') {
  $tmpRUT = '';
  $sep = array();
  $multi = 2;
  $suma = 0;
  if (empty($rut)) return 1;
  for ($i = 0; $i < strlen($rut); $i++) {
    if ($rut[$i] != ' ' AND $rut[$i] != ' ' AND $rut[$i] != '.' AND $rut[$i] != '-') $tmpRUT .= $rut[$i];
  }
  if ( strlen($tmpRUT) == 8 ) $tmpRUT = '0'.$tmpRUT;
  if (strlen($tmpRUT) != 9) return 2;
  $sep['rut'] = substr($tmpRUT,0,8);
  $sep['dv']  = substr($tmpRUT, -1);
  if ($sep['dv'] == 'k') $sep['dv'] = 'K';
  if (!is_numeric($sep['rut'])) return 3;
  if (empty($sep['rut']) OR $sep['dv'] == '') return 4;
  for ($i=strlen($sep['rut']) - 1; $i >= 0; $i--) {
    $suma = $suma + $sep['rut'][$i] * $multi;
    if ($multi == 7) $multi = 2;
    else $multi++;
  }
  $resto = $suma % 11;
  if ($resto == 1) {
    $sep['dvt'] = 'K';
  }
  else {
    if ($resto == 0) {
      $sep['dvt'] = '0';
    }
    else {
      $sep['dvt'] = 11 - $resto;
    }
  }
  if ($sep['dvt'] != $sep['dv']) return 5;
  return 0;
}
// --------------------------------------------------------
// Hasta aquí llega, lo de abajo fue una prueba de concepto
// no más, que pueden copiar tal cual.

$rut = '';
if (isset($_POST['rut'])) {
  $error = verifica_RUT($_POST['rut']);
  switch($error) {
    case 0 : echo 'Todo bien!!'; break;
    case 1 : echo 'RUT viene vacío'; break;
    case 2 : echo 'El RUT no viene con el mínimo de caracteres necesarios para validarlo'; break;
    case 3 : echo 'El RUT no viene en un formato numérico'; break;
    case 4 : echo 'El RUT o el dígito viene vacío.'; break;
    case 5 : echo 'El RUT y el dígito verificador no coinciden'; break;
    default: echo 'Error de la décimanovena dimensión!!! Corran en círculos!!!'; break;
  }
  $rut = $_POST['rut'];
}
?><html><head><title>Probando...</title></head><body onload="document.getElementById('rut').focus();">
<form  action="<?php echo $_SERVER['SCRIPT_NAME']; ?>" method="post">
<input type="text" id="rut" name="rut" value="<?php echo $rut; ?>" /><input type="submit" value="aceptar" /></form></body></html>

Conclusiones

Si sé, es un trabajo cochino que es muy muy muy probable que se pueda pulir mucho más que como está, pero este fue una volada que hice a la rapidita (especialmente la de PHP). A ver si algún día me animo a mejorarlo y optimizarlo. También le faltan muchas cosas todavía, pero por el momento es lo que hay.

Aunque me gustaría ahondar mucho más en el tema, por el momento sólo presentaré una pequeña función que puede ser bastante útil a la hora de reducir el peso de CSS gigantes, sin embargo, la verdadera ganancia puede no estar aquí, sino que en la compresión que se debe activar en el servidor, o bien ocupando ob_start() de PHP, pero como ya dije: eso ya es harina de otro costal y al ser más amplio preferiría dejarlo para otro post.

Sin embargo, a continuación les presento el pequeño script. Vamos... haz click en leer más

Entendiendo CSS

CSS es un invento genial. Mediante el mismo, y combinándolo inteligentemente con HTML, podemos controlar cualquier aspecto de nuestra página. Es, como casi todo en la Web, fácilmente interpretable y también pesa poco: aplicando sólo una hoja de estilos, podemos controlar todo el aspecto gráfico de la página. Sin embargo, y casi de forma tan variable como lo sea el gusto del programador, es también posible llenar un CSS demasiado con comentarios, espacios demás y hasta caracteres demás. De muestra, un botón:

html {
  background-color:#113355;
}
/* Algunos estilos */
p.hola, a:link {
  margin-left: 2px;
  margin-right: 2px;
  margin-top: 43px;
  margin-bottom: 43px;
}
/* El contenedor General de la página */
#wrapper {
  padding: 0px 0px 0px 0px;
  color: #5533AA;
}

Esto puede reducirse bastante, para que no quede tan críptico, dejé cada estilo en una línea:

html{background:#135}
p.hola,a:link{margin:43px 2px}
#wrapper{padding:0;color:#53A}

Explicaré algunas reglas básicas:

1. Los comentarios no sirven: si quieren un peso chico, eliminen todo comentario.
2. margin, padding y algunos otros tienen un formato reducido. Sin embargo, es algo que se explicará en otro artículo
3. El punto y coma final de cada declaración no es necesario. Elimínenlo.
4. Los colores se pueden reducir, siempre y cuando los tres pares RGB sean iguales. Es útil.
5. A CSS no le gustan mucho los espacios. Se pueden eliminar muchos.

Ahora bien, en el pequeño ejemplo de arriba, que son exactamente iguales, el peso del archivo se redujo de 263 bytes a 84 bytes. Ahora se pueden imaginar la misma situación, pero en la vida real donde el CSS no pesa algunos bytes, sino que bastantes kibibytes. (Eso serían bytes multiplicados por 1024). De todas formas, eliminando los saltos de línea, se puede dejar en 81 bytes, pero queda de difícil lectura.

Sin embargo, el tema que nos convoca hoy no hace algo tan avanzado, sino que simplemente elimina los puntos 1, 3 y la gran mayoría del punto 5. Aunque todavía está lejos de ser perfecto aunque hasta el momento he detectado que hace bien su pega.

<?php
  function compress($buffer) {
    $buffer = preg_replace('!/\*[^*]*\*+([^/][^*]*\*+)*/!', '', $buffer);
    $buffer = str_replace(array("\r\n", "\r", "\n", "\t", '  ', '    ', '    '), '', $buffer);
    $buffer = str_replace(array(';}','; }',': ',' {','; '),array("}\n","}\n",':','{',';'),$buffer);
    return $buffer;
  }

header('Content-type: text/css');
echo compress(file_get_contents('highslide.css'));
?>

En el ejemplo de arriba tomé el CSS de highslide, un script hecho en JavaScript que realiza el típico efecto zoom de una foto. El CSS de este script pesa 21.274 bytes, un poco más de 21KiB. Aunque el CSS en sí está bastante bien hecho, no está optimizado para la transferencia Web, tiene muchos espacios vacíos inútiles y también algunos comentarios, todo separado por un enter que parece que se le hubiera quedado pegado al programador.
Después de aplicar el script, quedó pesando 15.695 bytes, lo cual significa una reducción de 6KiB. Puede no sonar tanto, pero en cuanto a porcentaje estamos hablando de una reducción de peso de un poco más de un 26%, ¡sólo eliminando espacios innecesarios! Además, hay que tener en cuenta que se está agregando un enter después de cada declaración: al eliminar estos enter que en estricto rigor también están demás, obtenemos un archivo de 15.511 bytes, lo cual en porcentaje significa un poco más del 27%.

Ahora bien, la desventaja de este esquema es que cada vez que queramos modificar el CSS, tendremos que realizar el paso de conversión y luego escribir el archivo, algo bastante impráctico sobretodo si se está desarrollando continuamente. Para solucionar esto, se puede ampliar un poco la función de arriba, combinando CSS y PHP en un solo archivo.

<?php
  header('Content-type: text/css');
  ob_start("comprimir");
  function comprimir($buffer) {
    $buffer = preg_replace('!/\*[^*]*\*+([^/][^*]*\*+)*/!', '', $buffer);
    $buffer = str_replace(array("\r\n", "\r", "\n", "\t", '  ', '    ', '    '), '', $buffer);
    $buffer = str_replace(array(';}','; }',': ',' {','; '),array("}","}",':','{',';'),$buffer);
    return $buffer;
  }
?>
body{background:#1C762C none repeat scroll 0 0;color:#000;font-family:Arial;margin:0;padding:0}
img{border:none}
marquee{background:#FFF;height:168px;padding:0;text-align:center;width:130px}
a{color:#111;text-decoration:none}
ul{text-align:left}
<?php
  ob_end_flush();
?>

Pero, esto tiene un pequeño detalle: hay que guardarlo como un archivo .php, debido a que por lo general la configuración no permite establecer un .css como un script ejecutable de PHP. Lo que en el fondo se hace es generar un archivo PHP que genera CSS gracias a ob_start() que, con una explicación muy a la lijera, toma la salida y le aplica la función que definimos antes de enviarlo al explorador. Finalmente, debemos indicarle expresamente dónde termina el archivo.

De esta forma, se consigue comprimir todo el contenido. El único cambio que habría que hacer en HTML sería el siguiente:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="es">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
    <base href="http://looneyfactory.com/"/>
    <link rel="stylesheet" type="text/css" href="http://yui.yahooapis.com/3.0.0/build/cssreset/reset-min.css"/>
    <link href="estilo_general.css.php?v=1.0" rel="stylesheet" type="text/css"/>
  </head>
  <body>
<!-- el contenido del cuerpo -->
  </body>
</html>

Aquí pasan varias cosas interesantes. Primero llamamos a una aplicación de Yahoo, que es la encargada de resetear todos los valores predeterminados que puedan tener los navegadores. (¿Se acuerdan del artículo sobre reseteo de CSS?). Después de eso, llamamos a nuestro estilo, que en realidad es un script hecho en PHP. Además, le pasamos la cadena v=1.0 y esto tiene una razón bastante específica: Hoy en día, no es extraño encontrar que algunos sitios (como por ejemplo: Yahoo, Google y en general cualquier empresa grande que tenga empleados que algo cachan sobre la Web) tengan habilitada una caché que dura menos que 1 año. El CSS de Yahoo por ejemplo, expira en 10 años más. Sin embargo, no tiene ni una gracia que se tenga que cambiar el nombre del archivo cada vez que hay un pequeño cambio en el CSS. Es por eso, que se le agrega al más puro estilo $_GET de PHP un identificador único con lo cual el navegador sub-entiende que ese nombre de archivo (completo, incluido los parámetros) lo debe guardar en caché.

Ahora entendí un poco más... Y todo junto cómo sería?

Afortunadamente para ustedes, cuando empezé a escribir este post comencé también a trabajar en una class que me hiciera esto de forma automática. Sin embargo, y como siempre, aunque el requerimiento era bastante simple, terminé por meterle mucho más contenido que lo que originalmente iba a hacer.
Mayor información, tal como link hacia la class y qué cosas hace, las pueden encontrar en este post.

De esta forma, el CSS principal de CHW por ejemplo, pasa de pesar 43876 bytes a 5802 bytes, una compresión de un 87%!

Cómo se hace esto? Muy simple: se toma el o los CSS a procesarse, se eliminan los comentarios, los retornos de carros, los espacios que sobran, los tabs que sobran, se cambian todos los 0px a 0, los colores se convierten a su respectivo código corto y por último los colores se tratan de acortar de #EEAA11 a #EA1.
Por último, a ese archivo resultante se le aplica gzip y se manda al cliente. Por último, si el cliente ya tiene en su caché el CSS, simplemente se manda un código HTTP de que el archivo no ha sido modificado, reduciendo de esta manera ancho de banda.

Mi class trabaja con dos formas de caché, ambos configurables:
El primer caché se genera en el servidor. De esta manera, se pueden dar distintas combinaciones para distintos perfiles.
Si en una página cargo hola.css y chao.css y en otra página cargo hola.css y mundo.css, ambos tendrán una caché distinta.
Esta caché se puede activar o desactivar, aunque desactivado no tiene mucha gracia ya que cada vez que hay un request, se debe realizar todo el proceso de arriba nuevamente.

La segunda caché es la del cliente: si el CSS no ha cambiado entonces no descarga nada. Si en cambio, el archivo fuente ha cambiado o el cliente no tiene en caché el CSS se descarga nuevamente.
Esta caché se puede desactivar como también regular el tiempo que dura.

¿Qué ventajas tiene esto?

1. Los CSS quedan originales, no teniendo que renombrarse. Es tan fácil como llegar y editarlos en caso que sea necesario. Cuando se editan, se actualiza automáticamente la caché interna y se manda la nueva versión al cliente.
2. No más problemas extraños con distintos navegadores: la class se encarga de hablar con el navegador.
3. Menos HTTP requests por cliente.
4. Menos peso que transferir hacia el cliente.
5. De fácil integración: sólo son 2 líneas de código

Por último, también es posible enviar el CSS como un archivo (recomendado) o bien imprimirlo inline como parte del estilo.

Y de dónde se puede descargar esta maravilla? De acá:

http://unreal4u.users.phpclasses.org/browse/package/5950.html

En ese link se encuentra la class, documentación completa (en inglés, sorry es requisito del sitio), el archivo de configuración necesaria y por último un par de ejemplos.

Cualquier duda, puede ser mediante phpclasses.org o bien mediante CHW o por último, como comentario en este mismo blog

[UPDATE]: Saqué la versión 1.3 hace algunos días que incorpora algo nuevo: uno puede forzar la creación de un archivo caché (en el servidor) y ahora también existe la opción de sólo imprimir el nombre del archivo caché que genera. De esa forma, podemos incluirlo en nuestro código fuente sin tener otro archivo dando vueltas y que el Webserver se encargue de lidiar con la caché del navegador. (Aunque esto hay que configurarlo, mi class la hace solo )

Les cuento el pequeño problema: Hace ya bastante tiempo, tengo un servidor de desarrollo. Este servidor de desarrollo afortunadamente es bastante estable: funciona bien hace más de 1 año y sólo lo he reiniciado 2 veces a lo largo del año que recién pasó (Feliz año nuevo a todo esto): la primera fue debido a una costumbre windowsera y la segunda fue por una actualización importante del kernel. Sin embargo, lo realmente importante es que el downtime de este servidor es de menos de un 1% durante este año y eso fue sólo porque en el datacenter hubo una serie de malos entendidos que llevaron a que me desconectaron el servidor durante todo un fin de semana. Sino hubiese sido por este pequeño incidente, el downtime hubiese sido de menos de un 0.01% (Considerando ese 0.01% como el tiempo que se demora la máquina en reiniciar 2 veces durante el transcurso de un año).

Lo único malo de esto, es que Google piensa que este servidor tan estable debería aparecer en su listado, mientras que yo pienso todo lo contrario: es un servidor de desarrollo, y por lo general el contenido que se genera en este servidor, finalmente termina copiándose al server final.

A continuación las típicas preguntas:
¿Cómo es que llegaron a indexarme?
La verdad no tengo idea, lo más probable es que en alguna página tenía un link hacia el servidor de desarrollo lo cual llevó a Google a indexarla. Supongo que en el transcurso de 1 año eso es perfectamente factible: durante ese año lo más probable es que alguna vez haya puesto un link en alguna parte.

¿Cuál es el problema?
Que Google termina castigando al usuario final por contenido duplicado en una máquina de desarrollo. (medio WTF pero es como Google funciona). Es así como me encontré con la desagradable sorpresa de que buscando por un término fácilmente relacionable con una empresa para la cual estaba desarrollando una página, el servidor oficial aparecía en primer lugar y el servidor de desarrollo aparecía en cuarto lugar. Incluso habían usuarios que se habían creado una cuenta en el servidor de desarrollo a pesar de los múltiples avisos ¬¬.

¿Cómo quitarlo?
Me puse a investigar cómo dar de alta este servidor el cual nunca había querido indexar siquiera. Fue así como me inscribí en Google Webmasters donde, según una guía "oficial" de Google podría sacar la página de Google. Sin embargo, el link para sacarme que aparecía muy claro en el SS de la guía, ni siquiera me aparecía ¬¬.
Quedándome claro que ese no era el método, seguí leyendo el mismo artículo, que finalmente explicaba otros métodos para que la gran G no me siguiera indexando, los cuales eran bastante más atinados y fáciles de seguir que hacer clicks en un mar de links.

Primer método: retornar un 404

Google, tal como otros buscadores, desindexa un sitio que aunque previamente funcionaba bien, ahora retorna un error 404. Lo único "malo" de esto es que se tiene que eliminar todo el sitio, lo cual obviamente no era la idea: mal que mal, se necesita seguir desarrollando en la página y eliminarlo definitivamente no es la mejor opción.

Segundo método: Bloquear mediante robots.txt

Si bien es cierto nunca he hablado del robots.txt supongo que los que visitan este blog algo sabrán del mismo, y si no saben, una muy breve explicación: robots.txt es uno de los primeros archivos a visitarse por los buscadores, y en ella se indican los directorios o archivos que están prohibidos o permitidos para la indexación.
Sin embargo, no hay que olvidar que puede llegar a ser un arma de doble filo: este archivo es público, por lo tanto, es mejor no colocar rutas confidenciales, ya que como investigación previa a cómo hackear una página, este es sin duda uno de los primeros archivos que visitaré, justamente para ver si acaso existe alguna ruta confidencial. Facebook de hecho, tiene cosas bien interesantes en su robots.txt. Además, aunque la gran mayoría de los buscadores respetan este archivo, no todos lo hacen (Aunque son los menos).
En primera instancia, elegí este método ya que es el más rápido para bloquear sólo una sección. Se hace de la siguiente manera:

User-agent: *
Disallow: /
Esto le dice a todos los buscadores (un asterisco en User-agent indica todos los buscadores) que no indexen nada que se encuentre desde el home en adelante. Es decir, si pusiera esto en mi blog, estaría denegando expresamente a Google, Bing, Yahoo y otros que me indexen el sitio completo, subcarpetas y archivos incluidos.

Sin embargo, por esas cosas de la vida, uno quizás no querría denegar el acceso a todo el sitio, sino que sólo a una subcarpeta en específico a sólo Google.
User-agent: GoogleBot
Disallow: /carpeta/
Disallow: /login.php
Disallow: /otra-carpeta/archivo.jpg
Disallow: /*.gif$

Con esa orden, estamos denegando el acceso al GoogleBot a la carpeta llamada "carpeta" y mediante la segunda línea, al archivo llamado login.php que se encuentra en la raíz. Con la tercera línea, estamos denegando el acceso a archivo.jpg dentro de la carpeta "otra-carpeta" y finalmente, mediante la cuarta línea, estamos denegando el acceso a todos los archivos cuyo nombre termina en .gif.
Más información acerca de las expresiones regulares permitidos en robots.txt se puede encontrar en este enlace. (Hacer click en "Crear de forma manual un archivo robots.txt" para ver esa información).

Tercer método: Prohibir mediante meta-tags

Este método es bastante bueno, pero tiene algunas desventajas bastante grandes también. Básicamente, se trata de incluir un metatag en cada HTML que le indica a los buscadores que no se indexe tal página, las combinaciones útiles son:

<meta name="robots" content="noindex, follow">
<meta name="robots" content="index, nofollow">
<meta name="robots" content="noindex, nofollow">

Esto es bastante fácil de entender: el name es siempre "robots" si se quiere tomar en cuenta todos los buscadores. ("googlebot" en minúsculas si se quiere especificar solamente Google).
Content se refiere básicamente qué tipo de acciones son los que están prohibidos. Los posibles valores son siempre "index", "noindex", "follow" y "nofollow", pero obviamente no todas las combinaciones son posibles.

• index o noindex se refieren a si acaso se desea indexar el sitio: index para sí indexar, noindex para no indexar.
• follow o nofollow se refieren a seguir los enlaces de esa página; de esa forma; si pongo un nofollow en hola.php y hola.php contiene links hacia otras páginas o secciones de mi página, mediante esa directiva no se seguirán.

¿Las desventajas?

1. Si una página ya se encuentra indexada, lo más probable es que las imágenes también lo estén. Por lo tanto, si nuestra imagen se puede linkear directamente, seguirá indexada.
2. ¿Ya les dije que tenía un servidor de desarrollo cierto? Imagínense qué pasaría si se me olvida sacar esta regla de /includes/header.php y queden todas las páginas sin indexarse. Para los lentos: se borrarían todas las páginas desde los buscadores del dominio final lo cual obviamente no es la idea.

[Opcional] Google Hell

Si desde hace tiempo conocen de manejo SEO y otros relacionados, seguramente conocerán el término Google Hell. Este término se inauguró hace ya bastante tiempo atrás cuando la página cae en una cierta categoría de sitio spam y Google decide (de un día a otro) no mostrar más tu página en el buscador, a no ser que busques por el dominio mismo de la página. Aunque es altamente recomendado para quitar contenido de Google, también puede haber el riesgo de que la misma decida también tirar al infierno la página que está en producción, con lo cual el cliente no estará muy contento.
Sin embargo, el apellido "Hell" viene porque una vez que un sitio cae en esta categoría, es casi imposible salir. En la gran mayoría de los casos, se opta por simplemente comprar otro dominio y empezar de nuevo: las respuestas por parte de Google siempre son automatizados y son del tipo: "Lo sentimos, pero el proceso de indexación es automatizado y no podemos hacer nada". Sin duda alguna, el cliente cuya empresa se llama "Lavaseco S.A." y tiene el dominio lavaseco.cl no estará muy contento de tener que cambiar su super hiper genial dominio por alguno que sea mucho más difícil de recordar.
Obviamente es una excelente forma para que Google nunca más nos indexe, pero por cierto es la que NO debería aplicarse.

Conclusiones

Quitar una página desde un buscador puede ser un poco más difícil que tratar de incluirlo en alguno de ellos. Tampoco existe un método 100% fiable, a no ser que se caiga en el Google Hell. Sin embargo, no todo es imposible y aquí se expresaron al menos 3 métodos bastante fiables explicando sus ventajas y desventajas.
Sin duda, es que creo que el segundo método es el mejor de todos: nos permite tener un control bastante detallado de qué contenido está prohibido de indexar y además también bloquea la indexación de imágenes y otro tipo de documentos que no tengan un HTML de por medio, tales como documentos PDF, .doc y otros, los que no son posibles de bloquear con el tercer método.

Bueno, eso sería todo por hoy. Espero que haya sido claro en todo, y si no quedó muy claro, dejen su comentario más abajo

La primera regla de los errores es que es el usuario (final) jamás debe ver un error en pantalla. No es una buena idea que vea una pantalla en blanco que dice algo así como:

Fatal error N° 1002: Couldn't connect to MySQL, server responded: MySQL error 44: to busy

on line 3412 in file /home/asdf/public_html/includes/mysql.class.php

---

Apache v2.0.54 / PHP v5.2.12 on unreal4u.com

Principalmente por 3 razones:

• Puede no estar en el mismo idioma
• El mensaje de error generalmente es críptico, y asusta al usuario. El resultado es que el usuario cerrará la ventana y nunca más visitará el sitio pensando que fue él el que ocasionó el error. (Si el mensaje fuera el de arriba, parcialmente es así de todas formas xD)
• Por último, el más importante. Hay mucha información: sale la ruta del archivo que produjo el error, sale la línea y por último, si se encuentra habilitado, el servidor muestra qué está corriendo.

Por lo tanto, si vamos a mostrar un error, mínimo que sea en la misma página donde se produjo, en el idioma del usuario, con un error en lenguaje más humano, algo así como esto:

Lo sentimos, pero en este momento el servidor tiene demasiado tráfico

Lo primero en que pensé fue en la propiedad autocomplete="off", pero tiene algunos problemas asociados y no funciona de la mejor manera que digamos. Por ende, tratando de juntar un par de ideas, pensé en lo siguiente.

Click en "leer más" o "ver artículo completo" o como sea que esté traducido para ver la solución propuesta

Primera solución

Dije que podríamos haberlo hecho con autocomplete="off". Veamos cómo funciona:

<input type="text" autocomplete="off" id="asdf" name="asdf" value="" />

Con esa sola línea se supone que debería quedar desactivado el autocompletado, pero tiene un solo gran problema: no es compatible con la W3C.
Sin embargo, no hay que olvidarse que la W3C no revisa JavaScript, por lo que poniendo en el evento onload del body lo siguiente, sí se retorna un documento válido que cumplirá el mismo propósito:

document.getElementById("asdf").setAttibute("autocomplete","off");

Peeeero... aquí ocurre el otro problema: no todos los navegadores aceptan este tipo de instrucción, por lo que por ejemplo Firefox va a seguir llenando el input. Mal que mal, es una característica que tiene que funcionar a toda prueba para el navegador cierto?

Segunda solución (Siempre funciona)

El problema se genera justamente en el cliente: firefox o cualquier otro navegador simplemente toma en cuenta el nombre del elemento y lo llena de acuerdo a lo que tiene guardado. De esta forma, se hace posible que por ejemplo, mi nombre de usuario aparezca en todos los foros vBulletin, ya que muchos de ellos tienen el mismo nombre en el input.

Por lo tanto, una solución sería poder darle un nombre único a cada elemento que no queremos que se autocomplete. Sin embargo, hay que tener en cuenta que muchas veces un input de tipo texto que no haga nada es algo inútil: necesitamos hacer algo con ese elemento. El único problema es que... ¿cómo se llama dicho elemento si su nombre es totalmente al azar?
Bueno, para eso lo que se puede hacer es lo siguiente: tenemos que ver de qué manera podemos generar un nombre único pero a la vez tenemos que ver cómo lo podemos rescatar referenciándolo por ese nombre.

El truco en sí es bastante fácil: basta poner un elemento de tipo hidden y darle de valor el nombre del elemento y punto. Así de corta.

<?php
// Rescatando o revisando que el formulario enviado no sea vacío
  if (isset($_POST['qwerty']) AND !empty($_POST[$_POST['qwerty']])) {
// No es vacío, por lo que procedemos a imprimir o cualquier cosa
// que se haga dentro de un formulario enviado
    echo 'El valor es: <strong>'.$_POST[$_POST['qwerty']].'</strong><br />';
  }
?><form action="<?php echo $_SERVER['SCRIPT_NAME']; ?>" method="post">
<?php
// Primero establecemos un nombre único. "uniqid" retorna
// una id única (con 14 decimales de precisión gracias al
// segundo argumento), precedida por el tiempo en segundos
// Finalmente, a todo eso se le aplica un md5.
  $nombre = 'asdf_'.md5(uniqid(time(),TRUE));
// Imprimo la caja que se verá públicamente con su nombre único
  echo '<input type="text" name="'.$nombre.'" />';
// Imprimo un elemento de tipo hidden con valor == $nombre
  echo '<input type="hidden" name="qwerty" value="'.$nombre.'" />';
// Siempre es bueno desocupar la mayor cantidad de memoria posible
  unset($nombre);
?>
<br /><input type="submit" value="Aceptar" />
</form>

Por si lo quieren probar, aquí está la prueba de concepto.

Saludos !!