unreal4u's Personal Network » Javascript/jQuery

Algunas notas sobre el prefetching

unreal4u — Mon, 30 Jan 2012 21:29:17 +0000

Desde hace tiempo que sigo bien de cerca algo que me tenía bien intrigado: el prefetch de HTML5, que me parece demasiado buena idea y espero que todos los navegadores lo implementen ipso-facto. Sin embargo, quise echar una pequeña mirada a cómo funcionaba (si es que funcionaba) y específicamente a cuál era la sintaxis necesaria y cuáles son los pequeños trucos de la vida que se pueden aplicar para lograr el efecto deseado. Haz click en leer más para conocer los detalles de esta investigación que algunas sorpresas dio y también muchos dolores de cabeza.

¿Qué es el prefetching?

Desde la entrada de HTML5, aparte de los tags de audio y video, hubo algo que me llamó bastante la atención: el prefetch. Esta técnica consiste en adivinar lo que el usuario bajará en su siguiente click en nuestra página por lo que la idea detrás de esta técnica es bajar el mentado archivo o página desde ya para que de esta forma cuando el usuario haga el click no tenga que bajar el archivo nuevamente.
En teoría, suena bastante bien, pero quise llevarlo a la práctica para saber si acaso era factible o no poder implementar esta tecnología hoy en día. De acuerdo a casi todas las páginas web que consulté, simplemente había que incluir algunas cabeceras en nuestra página web para que milagrosamente funcionara el prefetching, lo cual me parecía demasiado bueno para ser verdad y así fue: resulta que el prefetching sólo ocurre bajo algunas condiciones y no siempre.

Como primer punto de aquiles, el prefetching sólo funciona en Firefox y en Chrome, desde la versión 3.6 y 13 respectivamente, pero sinceramente es un punto que poco importa, ya que estos dos navegadores juntos ya obtienen más de un 50% de participación en el mercado de los navegadores (fuente), por lo que nuestro grupo objetivo desde ya es bastante amplio.

Sin embargo, de aquí en adelante todo empieza a irse cuesta abajo. Resulta que el prefetching no funciona en muchos casos, y como podrán leer más adelante, el prefetching de Firefox simplemente no cumple su cometido, lo que baja nuestra cuota de mercado a sólo un 25%. La otra característica sobresaliente es que el uso más intenso que pretendía darle no funciona: sólo funciona si el recurso prefetcheado es un link (elemento ), y no una llamada ajax.

Preparación

Para poder saber de forma rápida si acaso el prefetching funcionaba, escribí 2 archivos: uno como índice principal y el otro de prefetching, con el siguiente código, primero vemos nuestro índice:



	Testing prefetch with HTML5
	
	
	

Please click here to display the (prefetched) page

Es un documento HTML5 estándar, con dos elementos link: uno para firefox (que ocupa rel=prefetch) y la otra para Chrome, que ocupa rel=prerender. Dato rosa: la diferencia entre ambas es que el prerender también renderea la gráfica de la página, mientras que el prefetch sólo realiza este paso cuando la página se hace visible. En un documento complejo podría quizás llegar a notarse este punto, pero para el 99,6% de las páginas restantes no habría ninguna diferencia. De todas formas, ambas directivas son necesarias, ya que uno funciona para Firefox y la otra para Chrome.

Sólo para realizar un test, tenemos dos "links": uno que carga el archivo mediante ajax, y la otra es simplemente un link. Hice esta separación ya que uno es dinámico y la otra es estática, y era probable que los navegadores hicieran una diferenciación entre ambos tipos.

Este será nuestro archivo que vamos a "prefetchear":

$fp = fopen('log.txt', 'a');
fwrite($fp,'['.strftime('%d-%m-%Y %T').'] - '.substr($_SERVER['HTTP_USER_AGENT'],strrpos($_SERVER['HTTP_USER_AGENT'], ' '),strlen($_SERVER['HTTP_USER_AGENT']))."\n");
fclose($fp);
sleep(3);
echo 'hello';

Por supuesto que tenemos un archivo llamado log.txt que tiene permisos 777. La principal razón del sleep era para simular la vida real y darle un tiempo de espera de carga de 3 segundos.

Empiezan las sorpresas

Con estos dos archivos empecé a hacer las pruebas, y grandes fueron mis sorpresas, ya que lo escrito en el papel es muy distinto a la práctica.

Primero dos links que me fueron de mucha ayuda:

http://browserspy.dk/prefetch.php

http://prerender-test.appspot.com/

El primero sirve para saber si el prefetching está funcionando para Firefox, mientras que el segundo sirve para verificar si el prefetching está funcionando para Chrome.
También resultó bastante útil el task manager de Chrome (Window|Task Manager), y este link, también para Chrome:
chrome://net-internals/#prerender

Ya con todas estas herramientas pude empezar a probar distintas configuraciones y estos fueron los resultados:

Firefox en Mac NO soporta prefetching. Así es, NO. Bajo ninguna circunstancia.
Firefox en Windows no tuvo mayores inconvenientes en hacer el prefetch, pero en cuanto se hace click en el documento "prefetcheado", lo empieza a descargar de nuevo. Más sobre esto después.
Chrome a partir de la versión 13 funciona bien el prerendering. ANTES de esta versión, no hubo caso en que funcionara.
Sólo se descargan documentos estáticos. Olvídense de pre-cargar ajax, no funcionará.

¿Qué pasa con Firefox?

Hasta que me di cuenta de lo que pasaba en Firefox, estaba feliz de que funcionara, pero me llevé una gran desilusión. Resulta que Firefox después de haber hecho el prefetching y cuando uno ya hace click en el link... empieza a descargar el documento de nuevo! El gran problema de esto, es que se pierde todo el objetivo de hacer un prefetching y más encima realiza un request adicional que nunca ocupará, gastando recursos en nuestro servidor.
Hay sin embargo un test que no he hecho y que tampoco creo que valga la pena: establecer cabeceras explícitamente en el futuro para que Firefox piense que el recurso que acaba de rescatar también es válido para el siguiente request.
El único reparo que tengo con esto es que si tenemos una cabecera de prefetching es por que sabemos que el próximo recurso a rescatarse será el que le estamos indicando... ¿para qué necesito decirle explícitamente que quiero que conserve ese recurso?

Conclusiones

Aunque Firefox soporta desde la versión 3.6 el concepto de prefetch, lo hace bastante mal. Uno pensaría que ya con tanto tiempo "soportando" prefetching, funcionaría bien pero como queda demostrado, lo soporta de forma paupérrima.
Chrome en cambio me alegró el día ya que funciona y bastante bien. Incluso funciona si tenemos un javascript como el que sigue:

var app = {
    prefetchLinks: function(){
        var hrefs = $("a.prefetch").map(function(index, domElement){
            return $(this).attr("href");
        });
        return $.unique(hrefs);
    },

    addPrefetchTags: function(){
        this.prefetchLinks().each(function(index,Element){
            $("", {
                rel: "prefetch", href: Element
            }).appendTo('head');
            $('', {
                rel:'prerender', href: Element
            }).appendTo('head');
        });
    },
};
$(document).ready(function(){
    app.addPrefetchTags();
});

Sacado (y modificado) desde esta página. Las modificaciones que tiene son en la llamada final de la función y en agregar el soporte para Chrome.

La gran sorpresa de esta función es que aunque construye bien el documento en todos los navegadores, el objetivo final sólo se logra en Chrome, ya que todos los demás navegadores no saben qué hacer con las etiquetas recién construidas, lo cual incluye -para mi sorpresa- a Firefox, que ni siquiera comienza a bajar los documentos que queramos rescatar.

Con esta pequeña investigación al respecto, creo que dejaré descansar el tema por uno o dos años para luego ver si se ha avanzado algo y si en ese futuro sirve o no.
También quiero dejar una pequeña enseñanza: aunque muchas páginas juran que el prefetching funciona con sólo agregar algunas líneas a tu código fuente, siempre hay que experimentar y tratar de hacer funcionar las cosas por uno mismo. En este caso, quedó demostradísimo que no es llegar y agregar links, ya que la funcionalidad final sólo se logra en un navegador mientras que para el otro es sólo una gastadera de recursos. Por si fuera poco, casi todas las páginas que promocionan el uso del prefetching sólo incluyen el código necesario para Firefox haciendo su solución totalmente inútil para la vida real, así que: cuidado con copy-paste!

Manito de gato al blog

unreal4u — Sun, 17 Jul 2011 06:26:47 +0000

Hace mucho tiempo que quería hacer algunas cosas nuevas en el blog, entre las cuales estaban:

Una actualización general: Cuando instalé el blog WordPress iba en la versión 2.7.9 y nunca más la actualicé.
Actualización de Plugins: Aunque no me gusta ocupar plugins, sí tenía algunos que estaban sumamente desactualizados.
Incorporar botones sociales: Hoy en día, casi infaltables si uno quiere hacer las cosas de forma rápida.
Cambiar el blog de máquina: Antes estaba en una máquina casi exclusiva, ahora, estoy en el servidor web que sirve todas las páginas, pero podré administrar mejor.

Así que buenas noticias: actualicé WordPress a la última versión (3.2.1), actualicé los plugins a la última versión y también incorporé los botones +1 de Google, Like de Facebook y el Tweet Button de Twitter. Y para dejar algo de aporte, revise el código después del salto.

La verdad, pensé que incorporar estos botones iba a ser un poco más complicado, pero resultó bastante más fácil de lo que pensé. Lo primero que tenemos que hacer es visitar cada una de las páginas arriba mencionadas y seleccionar el estilo adecuado a nuestro gusto. Una vez hecho eso, procedemos a su instalación.

Botón +1 de Google

En header.php de nuestro theme, justo antes del cierre de la cabecera, agregamos el siguiente código:

Luego, para cuando queramos agregar el botón en algún lado, digamos single.php o index.php, sólo basta con:

size y href son obviamente configurables. Revisen también la página de Google, porque al incluir el primer javascript, es posible setear algunas configuraciones de inmediato, como por ejemplo el idioma.

Like de Facebook

Este botón es quizás el más difícil de estilar debido a que trabaja directamente con HTML en vez de CSS para eso. De todas formas, es bastante fácil, basta con agregar este código:

Pueden revisar las opciones que ofrece el botón en el mismo link que cité arriba, de las 3 opciones, es la mejor documentada.

Tweet Button de Twitter

De las tres, es la que peor documentación tiene, sin embargo, su inclusión sigue siendo, tal como los demás botones, casi un chiste de lo fácil que es.
Lo primero que tenemos que hacer es incluir el siguiente código en nuestra cabecera:

Y después, cuando queramos imprimir el botón:

Tweet

Y con eso, quedará inmediatamente insertado en nuestro blog.

Espero que les haya servido de ayuda para además, revitalizar un poco el blog.

Algunos links interesantes

unreal4u — Fri, 04 Feb 2011 03:23:00 +0000

Como siempre, navego en busca de información interesante, y aquí les traigo algunos links de interés (que además me servirán para desocupar un par de pestañas del navegador). Están ordenadas por temática, y hay de todo un poco, desde generadores de passwords hasta guías sobre cómo hacer extensiones de classes para Magento.

jQuery / Javascript:
Una botonera hecha con jQuery y cuyo efecto me encantó.
Ordenar un arreglo con drag & drop, enviando una solicitud via Ajax al server principal.

PHP:
Cómo crear un daemon en PHP, excelente artículo.
Comprendiendo cómo ocupar closures en PHP.
Del mismo blog, aprendiendo cómo usar Reflection en PHP.
Desde DeveloperWorks, un artículo que explica cómo optimizar PHP en 5 simples pasos, bastante básico pero certero.
Interesantísimo artículo de cómo ocupar Memcached, APC y/o directamente el sistema de archivos.

MySQL:
Del blog personal del creador de menéame, explica cómo optimizó una consulta en el transcurso de 5 años. Mención aparte se lo llevan los comentarios donde aprendí varias cosas nuevas.

WordPress:
Una guía bastante buena que nos enseña cómo optimizar (y asegurar) wp-config.php, ese archivo tan vital de WordPress.
¿Quiéres saber cómo funciona WordPress y su sistema de funciones? Échale un miro a este post donde definen 35 funciones (bastante) útiles para WP.

Magento:
La mejor manera de trabajar en Magento: extendiendo classes. Por lo mismo, no te puedes perder este artículo donde se explica con bastante detalle cómo crear una extensión.

CSS:
Completo listado de todas las propiedades de CSS y cuáles son soportadas en sus distintas versiones.
Una guía acerca de los pseudo-selectores de CSS, lectura recomendada para aquellos que quieran sacarle el jugo a CSS.

Misceláneos:
¿Alguna vez has tenido que armar una página con un mapa de Google Maps y tienes que averiguar las coordenadas? Bueno, entonces sabrás el dolor de cabeza que representa averiguar las mismas, hasta ahora. Sólo basta ubicar bien el puntero en esta página especialmente dedicada a tal propósito y estás listo: ¡ya tendrás esas coordenadas!
¿Necesitas generar una contraseña segura de forma rápida? Sin duda que esto te ayudará mucho.

Revisión de RUT con Javascript y PHP (Revisited)

unreal4u — Wed, 22 Sep 2010 03:24:42 +0000

Sí, es cierto, ya existe un post al respecto. Pero estoy viendo en Google Analytics que todo lo relacionado con el RUT es uno de los términos más buscados para la página, así que aprovecho de pegarle una revisión a ese post que ya tiene un poco más de 6 meses, así que bienvenido a la revisión del RUT como debería haber sido.

Como ese título siempre me ha llamado bastante la atención, es que le daré un enfoque bastante especial a que así sea. Este artículo estará separado en 3 partes: la primera, una explicación teórica sobre qué es el RUT y cuál es su función. La segunda, el algoritmo en JavaScript y el tercero, el algoritmo en PHP, obviamente estas últimas dos han sido revisados, actualizados y mejorados con respecto a su primera versión, desde la llamada inicial que se hace a la función, pasando por expresiones regulares y la detección automática del tipo de identificador: RUT o RUN.

Barniz teórico

En Chile, comúnmente se le denomina RUT tanto al RUT (Rol Único Tributario) como al RUN (Rol Único Nacional). La diferencia está en que el primero es un identificador de empresas mientras que el segundo sólo es para personas naturales. En este artículo, me referiré indistintamente a RUT o RUN.

Bueno, este número que consiste en un número de 1.000.000 a 99.999.999 es un identificador único a cada persona o empresa en Chile. Sé que también existe RUT en Argentina pero como no lo conozco (aunque tengo entendido que el algoritmo es bastante parecido) tocaré sólo el RUT chileno.
Además de esto, también se le une un dígito verificador que va de 0 a 9, más la letra K (representando 11), que no es nada más que una operación matemática basada en el número en sí para filtrar un poco que el número sea correcto.

Por lo tanto, este número, con la debida importancia que tiene, ha sido convertido casi en un estándar para la informática: un número único por persona, con límites conocidos, un checksum conocido y que se puede guardar fácilmente en una base de datos es lo único que una persona necesita para implementar el famoso RUT o RUN en su aplicación.

Sin embargo, siendo un número de millones, tenemos que existe una secuencia de 7 dígitos como mínimo y 12 como máximo que tiene que ingresar el usuario: tierra fértil para que el usuario se equivoque sin darse cuenta, más aún tratándose de una combinación de dígitos y signos de puntuación, y si queremos una base de datos que sea consistente... pues no podemos darnos el lujo de dejar que el usuario ingrese cualquier cosa.

Para esto, nació obviamente el último dígito de la secuencia, separada por una raya para distinguirlo, que lo que hace es revisar que el RUT ingresado corresponde a un número válido, el cual; mediante un algoritmo; se puede verificar (Y de ahí el nombre "Dígito Verificador").

En la práctica: JavaScript

Sin mayores secretos, la que más modificaciones sufrió fue la versión de Javascript, ya que se quitaron muchas partes que estaban redundantes y se resolvió que sólo iba a devolver un verdadero o falso. Si desean en cambio que retorne un número de error, pues con el código de PHP podrán modificar el de Javascript.

function verifica_rut(c){
  var r=false,d=c.value,t=d.replace(/\b[^0-9kK]+\b/g,'');
  if(t.length==8){t=0+t;};
  if(t.length==9){
    var a=t.substring(t.length-1,-1),b=t.charAt(t.length-1);
    if(b=='k'){b='K'};
    if(!isNaN(a)){
      var s=0,m=2,x='0',e=0;
      for(var i=a.length-1;i>=0;i--){
        s=s+a.charAt(i)*m;
        if(m==7){m=2;}
        else{m++;};
      }
      var y=s%11;
      if(y==1){x='K';}
      else{
        if(y==0){x='0';}
        else{e=11-y;x=e+'';};
      };
      if(x==b){r=true;c.value=a.substring(0,2)+'.'+a.substring(2,5)+'.'+a.substring(5,8)+'-'+b};
    }
  }
  return r;
}

y minificado:
function verifica_rut(c){var r=false,d=c.value,t=d.replace(/\b[^0-9kK]+\b/g,'');if(t.length==8){t=0+t;};if(t.length==9){var a=t.substring(t.length-1,-1),b=t.charAt(t.length-1);if(b=='k'){b='K'};if(!isNaN(a)){var s=0,m=2,x='0',e=0;for(var i=a.length-1;i>=0;i--){s=s+a.charAt(i)*m;if(m==7){m=2;}else{m++;};}var y=s%11;if(y==1){x='K';}else{if(y==0){x='0';}else{e=11-y;x=e+'';};};if(x==b){r=true;c.value=a.substring(0,2)+'.'+a.substring(2,5)+'.'+a.substring(5,8)+'-'+b};}}return r;};

Código en PHP

Aunque sufrió menos cambios que su simil en Javascript, tuvo una modificación bastante grande que fue el empleo de expresiones regulares para eliminar cualquier caracter que no deba ir en un RUT o RUN: de esa forma, se elimina cualquier caracter que no sea del 0 al 9, o la letra k (mayúscula o minúscula).

function verifica_RUT($rut='') {
  $sep = array();
  $multi = 2;
  $suma = 0;
  if (empty($rut)) return 1;
  $tmpRUT = preg_replace('/[^0-9kK]/','',$rut);
  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;
}

Uniendo todos los cabos sueltos

Por supuesto que el ejemplo completo que incluye revisión (y formateo de RUT) en Javascript como en PHP es algo que no podía faltar:

= 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;
}
?>Verificar RUT

Y eso sería todo amigos

Abrir todos los links externos en nueva ventana

unreal4u — Sun, 29 Aug 2010 14:18:09 +0000

Hace un tiempo atrás, necesitaba que todos los links externos fueran abiertos en una nueva ventana. Primero hice una función en PHP que cuando construía el link, detectaba si el mismo era interno o externo y si era externo, lo dejaba con el famoso target="_BLANK". Sin embargo, al poco tiempo después me di cuenta que ésta no era la solución ideal ya que fallaba en dos aspectos fundamentales: Si el link era construido mediante TinyMCE (o sea, por el usuario), no pasaba por el "constructor" de links. Por otro lado, el código generado no era compatible con la W3C en el modo estricto (En este modo, se elimina el atributo "target").
Así que me puse a investigar qué necesitaba para que cumpliera con los dos propósitos... ¿La respuesta? JavaScript, y si podía utilizar el poder de selección de la librería jQuery, aún mejor. El resultado fue que todos los links externos de la página, independiente de quién las haya creado, se abren en otra ventana y lo mejor de todo es que el código de la página es compatible con la W3C.

$(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.

Verificar RUT con Javascript y PHP

unreal4u — Mon, 29 Mar 2010 04:08:59 +0000

Atención! Este es una versión antigua! Existe una versión más nueva disponible aquí

Sí, estamos totalmente de acuerdo: hay por lo menos unos 50 validadores distintos si buscamos en Internet. Sin embargo, este validador es uno distinto: lo hice yo

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;i50000000){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'];
}
?>Probando...

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.