Expresiones regulares en Javascript

El problema recurrente

Siempre que hacemos un formulario para solicitar datos de entrada necesitamos validar las entradas. Una de las formas más básicas para validar es mediante expresiones regulares. Este deberia ser una de las primeras etapas de validación. 

Nunca tengo a mano un listado con las expresiones más comunes, asi que aca anoto 3 que son bastantes comunes. Están expresados para utilizar en javascript, pero son facilmente adaptables.

Fecha

^[0-9]{1,2}/[0-9]{1,2}/[0-9]{4}$

Mail

^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$

CUIT Argentina

El mejor para lo último. Agrego también la función para validar el dígito verificador.

^[0-9]{2}-[0-9]{8}-[0-9]$

function validarCUIT(cuit){
        cuit = cuit.toString().replace(/[-_]/g, "");

        var codigo_valido = true;
        if(cuit.length != 11)
            codigo_valido = false;
        else {
            /* Funcion de CUIT encontrada en internet */
            var mult = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
            var total = 0;
            for(var i = 0; i < mult.length; i++) {
                total += parseInt(cuit[i]) * mult[i];
            }
            var mod = total % 11;
            var digito = mod == 0 ? 0 : mod == 1 ? 9 : 11 - mod;
            codigo_valido = digito != parseInt(cuit[10]);
        }
        return codigo_valido;
}

A medida que vaya utilizando nuevas, las voy a ir agregando. Saludos!

El criticado goto

Una discusión reiterada con mis amigos programadores es acerca el uso del goto. En  cualquier libro sobre lenguajes de programación se lo nombre, pero casi todos recomiendan evitar su uso. Este último punto es sobre el cual peleamos de manera sistemática: siempre me dicen que usarlo está mal, de manera inapelable.

Yo no creo que esto sea así. Es verdad que el 99% de las veces en las que se podría utilizar esta sentencia, usarla estaría mal desde el punto de vista de legibilidad del código, principalmente. Pero hay casos en los que utilizarlo hacen el código mas entendible. El problema es que estos casos son muy puntuales, y no se los nombra, al menos con la fuerza necesaria para recordarlos, en los libros de programacion. Todo se reduce a "Usar el goto esta mal".

Ejemplos

Un ejemplo muy claro en el que el uso se justifica, para mi, es el siguiente:

bool encontre = false;
for (int i = 0; i < vector.size(); ++i) {
 for (int j = 0; j < otro_vector.size(); ++j) {
   for (int k = 0; k < otro_vector_mas.size(); ++k) {
    if (condicion de corte){
     encontre = true;
     break;
    }
   }
   if (encontre == true)
    break;
 }
 if (encontre == true)
  break;
}

En este ejemplo,se recorren 3 vectores de forma anidada y se busca una condición de corte al recorrer el tercer vector (podría ser, por ejemplo, que la suma de los elementos de los 2 primeros vectores sea igual al tercero). El caso se generaliza para cualquier cantidad de vectores. Sin utilizar goto, se debe tener una variable booleana, y luego, al salir de cada ciclo chequear por esta variable para saber si cortar el recorrido o no. Creo, que utilizando goto queda un código más limpio:

bool encontre = false;
for (int i = 0; i < vector.size(); ++i) {
 for (int j = 0; j < otro_vector.size(); ++j) {
   for (int k = 0; k < otro_vector_mas.size(); ++k) {
    if (condicion de corte){
     encontre = true;
     goto fin_recorrido;
    }
   }
 }
}
label fin_recorrido;

En este caso no hay que chequear nada al salir de cada ciclo, quedando un código con menos condicionales, y, a mi entender, mas legible y fácil de seguir. Siempre hay que tener en cuenta de usar nombres significativos tanto para las variables como para las etiquetas del goto, pero eso es una condición general para poder programar con cualquier tipo de sentencia :)

Espero sus comentarios sobre tan delicado tema.

Saludos!