Expresiones regulares

sábado, febrero 21, 2009 11 Comments

Hola compañeros javeros anónimos, bueno como sabemos siempre estamos en desventaja a la hora de pedir datos al usuario ya que tenemos que validar la entrada, por lo general ocupamos las expresiones regulares para validar o método matches y en ella ocupamos las clases predefinidas de caracteres que podemos usar con las expresiones regulares (\D \W \S ).
Bueno aquí les dejo algunas expresiones regulares que arme para validar la entrada del curp, rfc y numero de credencial espero que les sirva =).


  1. /*Método que tiene la función de validar el curp*/
  2. public boolean validarCurp(String curp){
  3. curp=curp.toUpperCase().trim();
  4. return curp.matches("[A-Z]{4}[0-9]{6}[H,M][A-Z]{5}[0-9]{2}");
  5. }//Cierra método validarCurp



  1. /*Método que tiene la función de validar el número de credencial*/
  2. public boolean validarNumCreden(String numCrede){
  3. numCrede=numCrede.toUpperCase().trim();
  4. return numCrede.matches("[A-Za-z]{6}[0-9]{8}[H,M][0-9]{3}");
  5. }//Cierra método validarNumCreden





  1. /*Método que tiene la función de validar el rfc*/
  2. public boolean validarRfc(String rfc){
  3. rfc=rfc.toUpperCase().trim();
  4. return rfc.toUpperCase().matches("[A-Z]{4}[0-9]{6}[A-Z0-9]{3}");
  5. }//Cierra método validarRFC


Por último dejo una incógnita ya que no pude armar una expresión funcional que me validara la entrada de texto, esto con el fin de validar nombres y apellidos, aceptando caracteres como ñ y asentó ya que si recordamos los gringos no ocupan la ñ mmm que mal.

  1. /*Valida que los datos entrantes sean cadenas sin ingresar numeros recibe una cadena
  2. si la cadena contiene numeros mandara un valor falso en caso contrario sera verdadero*/
  3. public boolean validarText(String cadena){
  4. boolean bien=false;
  5. String texto="";
  6. texto=cadena.trim();
  7. texto=texto.replace(" ","a");
  8. texto=texto.replace("ñ","a");
  9. if(!texto.matches("[a-zA-Z]*\\D{3}"))
  10. bien=true;
  11. return bien;
  12. }//Cierra metodo validarText


Como ven en este método ocupe la clase replace para remplazar los caracteres como (ñ) por una (a) así también como los espacios, de igual forma si es menor a tres mandara false ya que no existen nombres menores a tres, pero ni con todo esto pude hacer que aceptara los acentos ya que algunos apellidos los tienen, esperando puedan resolver este problema dejo el código fuente y espero encontrar una solución a mi problema .
 --------------------
UPDATE 08/11/11
------------------------
Antes que nada quiero aclarar que este post esta enfocado a dar una introducción a las expresiones regulares y los ejemplos mostrados son meramente prácticos, no se recomienda su uso en aplicaciones empresariales o de carácter formal. Ahora si se desea saber mas información a detalle de manera formal pueden revisar esta información que nos dejo un usuario del blog:

"Según el mismo SAT las expresiones regulares correctas para el RFC y CURP en México son las siguientes:

CURP: [A-Z][A,E,I,O,U,X][A-Z]{2}[0-9]{2}[0-1][0-9][0-3][0-9][M,H][A-Z]{2}[B,C,D,F,G,H,J,K,L,M,N,Ñ,P,Q,R,S,T,V,W,X,Y,Z]{3}[0-9,A-Z][0-9]

RFC: [A-Z,Ñ,&]{3,4}[0-9]{2}[0-1][0-9][0-3][0-9][A-Z,0-9]?[A-Z,0-9]?[0-9,A-Z]?

Lo pueden corroborar en: ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/cfd/iedu.pdf

En la página 3"

o también pueden revisar el post de la librería para generar el RFC y CURP

 --------------------
UPDATE 21/10/15
------------------------

Ejemplo para expresión regular de CURP  https://vidadigital.com.mx/ingenieria/web/expresiones/regulares/curp/

Gracias por dejar sus comentarios


Siguenos en nuestras redes sociales.

11 comentarios:

  1. Que tal, no estoy seguro de la expresión regular utilizada para RFC, la probé en la siguiente página con esta cadena : VECJ880326XXX y me devuelve una No concordancia

    ResponderEliminar
  2. EL RFC se debe validar:

    Persona Física
    Longitud de 13 Caracteres
    Los primeros 4 digitos deben ser letras A-Z o un &
    Los siguientes 6 deben ser digitos
    - los primeros 2 dígitos deben tener un rango entre 0 a 99 (inclusive)
    - los dígitos 3 y 4 deben tener un rango entre 1 a 12 (inclusive)
    - los dígitos 5 y 6 debeb tener un rango entre 1 y 31
    Tomando estos digitos se puede hacer una validación conviertiendo a una fecha de año-mes-dia. Esto porque un RFC AAAA880230XXX puede pasar la validación. De tal manera que si el sistema puede convertir a fecha entonces se validad que realmente es correcto los 6 digitos del RFC.

    Los últimos 3 Caracteres se conocen como Homoclave y se calcula:

    ...

    Mejor les dejo el código..
    Espero les sirva

    ResponderEliminar
  3. public boolean verificaRfc(String rfcValidar, int tipoCliente) throws VSException {
    // Declaracion de Variables
    boolean regreso = false;
    String fechaRfc = "";
    String homoClave = "";
    String mensajeError = "";
    if(rfcValidar == null ){
    throw new VSException("La Longitud del RFC no es Valida");
    }
    int longitudRfc = rfcValidar.trim().length();

    if(longitudRfc == 0 || (tipoCliente == 1 && longitudRfc != 13) || (tipoCliente == 2 && longitudRfc != 12) ){
    throw new VSException("La Longitud del RFC no es Valida");
    }

    if(tipoCliente == 0){
    throw new VSException("El Tipo de Cliente no existe");
    }


    char primerCaracter = rfcValidar.charAt(0);
    char segundoCaracter = rfcValidar.charAt(1);
    char tercerCaracter = rfcValidar.charAt(2);
    char cuartoCaracter = rfcValidar.charAt(3);
    fechaRfc = rfcValidar.substring(longitudRfc - 9, longitudRfc - 3);
    homoClave = rfcValidar.substring(longitudRfc - 3, longitudRfc);

    // Validacion para los tres Primeros Caracteres del RFC (Deben ser Letras)
    if ( ( Character.isLetter(primerCaracter) || String.valueOf(primerCaracter).equals("&") )
    && ( Character.isLetter(segundoCaracter) || String.valueOf(segundoCaracter).equals("&") )
    && ( Character.isLetter(tercerCaracter) || String.valueOf(tercerCaracter).equals("&") ) ) {

    // Validacion del Cuarto Caracter del RFC
    if ( ( tipoCliente == 1 && ( Character.isLetter(cuartoCaracter) || String.valueOf(cuartoCaracter).equals("&") ))
    || tipoCliente == 2 ) {
    // Validacion de la Fecha del RFC
    if ( validaFecha(fechaRfc) ) {
    // Validacion de la Homo Clave del RFC.
    if (validaHomoclave(homoClave)) {
    if ( calculaDigito(rfcValidar, tipoCliente, longitudRfc)) {
    regreso = true;
    }
    else {
    throw new VSException("Error en el Digito Verificador del RFC.. Digito Valido " + digitoCalculo );
    }
    } // Validacion de la Homo Clave del RFC.
    else {
    throw new VSException("Error en la Homoclave del RFC ") ;
    }
    } // Validacion de la fecha del RFC
    else {
    throw new VSException("Error en los Caracteres de la Fecha del RFC ") ;
    }
    } // Validacion del Cuarto Caracter del RFC
    else {
    throw new VSException("Error en los Caracteres del Nombre del RFC");
    }
    //validaFecha(String aFechaRfc)
    } // Validacion para los tres Primeros Caracteres del RFC (Deben ser Letras)
    else {
    throw new VSException("Error en los Caracteres del Nombre del RFC");
    }
    return regreso;
    } // verificaRfc

    ResponderEliminar
  4. /**
    * Metodo para Validar la fecha del RFC
    */
    private boolean validaFecha(String aFechaRfc) {
    boolean regresoFecha = false;
    int anioFecha = 0;
    int mesFecha = 0;
    int diaFecha = 0;

    // Validacion de los Caracteres de la fecha (Deben ser Digitos)
    CharacterIterator itFecha = new StringCharacterIterator(aFechaRfc);
    for (char chFecha = itFecha.first(); chFecha != CharacterIterator.DONE; chFecha = itFecha.next()) {
    if ( Character.isDigit(chFecha)) {
    regresoFecha = true;
    } else {
    return false;
    }
    }

    if (regresoFecha) {
    anioFecha = Integer.parseInt(aFechaRfc.substring(0, 2));
    mesFecha = Integer.parseInt(aFechaRfc.substring(2, 4));
    diaFecha = Integer.parseInt(aFechaRfc.substring(4,6));

    // Validacion de la Fecha (Año, Mes y Dia)
    if ( (anioFecha >= 0 && anioFecha < 100) && (mesFecha > 0 && mesFecha < 13) && (diaFecha > 0 && diaFecha < 32) ) {
    regresoFecha = true;
    }
    else {
    return false;
    }
    }
    return regresoFecha;
    } // validaFecha(String aFechaRfc)

    /**
    * Metodo para Validar la Homoclave del RFC
    */
    private boolean validaHomoclave(String ahomoClave) {
    boolean regresoHomoclave = false;
    // Validacion de los Caracteres de la Homo Clave
    CharacterIterator itHomoClave = new StringCharacterIterator(ahomoClave);
    for (char chHomoClave = itHomoClave.first(); chHomoClave != CharacterIterator.DONE; chHomoClave = itHomoClave.next()) {
    if ( Character.isDigit(chHomoClave) || Character.isLetter(chHomoClave) || String.valueOf(chHomoClave).equals("&")) {
    regresoHomoclave = true;
    }
    else{
    return false;
    }
    }
    return regresoHomoclave;
    } // validaHomoclave(String ahomoClave)

    ResponderEliminar
  5. /**
    /* Metodo para Calcular el Digito Verificador del RFC
    */
    private boolean calculaDigito(String aRfcValidar, int atipoCliente, int alongitudRfc) {
    boolean regresoDigito = false;
    //addTrace("Inicio Digito Verificador " + regresoDigito );
    String digitoRFC = "";
    //String digitoCalculo = "";

    int posicion = 1;
    int wCalculo = 0;
    int wPaso =0;
    int wDigito =0;

    if (atipoCliente == 2) {
    wCalculo = 37 * 13;
    }

    digitoRFC = String.valueOf(aRfcValidar.substring(alongitudRfc - 1, alongitudRfc));

    // Calculo del Digito Verificador
    CharacterIterator itRfc = new StringCharacterIterator(aRfcValidar.substring(0, alongitudRfc - 1));
    for (char chRfc = itRfc.first(); chRfc != CharacterIterator.DONE; chRfc = itRfc.next()) {

    // Buscar el valor del digito en la Tabla de Caracter - Valor
    int valor = .....

    wCalculo += valor * (alongitudRfc + 1 - posicion);

    posicion ++;
    }

    wPaso = (wCalculo/11);
    wPaso = wPaso * 11;
    wDigito = wCalculo - wPaso;
    if ( wDigito == 0 )
    digitoCalculo = "0";
    else {
    if ( (11 - wDigito ) == 10 )
    digitoCalculo = "A";
    else
    digitoCalculo = String.valueOf(11 - wDigito);
    }

    if ( digitoCalculo.equals(digitoRFC) ) {
    regresoDigito = true;
    }
    else {
    //throw new Exception("Error en el Digito Verificador del RFC.. Digito Valido " + digitoCalculo);
    return false;
    }
    //addTrace("Digito Verificador " + regresoDigito );
    return regresoDigito;
    } // calculaDigito(String aRfcValidar, int atipoCliente)

    ResponderEliminar
  6. Tabla de Caracter - Valor
    Para calcular el Digito verificador

    caracter valor
    -------- ------
    & 24
    0 0
    1 1
    2 2
    3 3
    4 4
    5 5
    6 6
    7 7
    8 8
    9 9
    A 10
    B 11
    C 12
    D 13
    E 14
    F 15
    G 16
    H 17
    I 18
    J 19
    K 20
    L 21
    M 22
    N 23
    O 25
    P 26
    Q 27
    R 28
    S 29
    T 30
    U 31
    V 32
    W 33
    X 34
    Y 35
    Z 36

    ResponderEliminar
  7. Que tal wvillegasm! Gracias por tus comentarios vamos a validar tu codigo y crearemos un Post al respecto ¿Tienes algun link donde contactarte? Para agregarlo en el post

    ResponderEliminar
  8. Según el mismo SAT las expresiones regulares correctas para el RFC y CURP en México son las siguientes:

    CURP: [A-Z][A,E,I,O,U,X][A-Z]{2}[0-9]{2}[0-1][0-9][0-3][0-9][M,H][A-Z]{2}[B,C,D,F,G,H,J,K,L,M,N,Ñ,P,Q,R,S,T,V,W,X,Y,Z]{3}[0-9,A-Z][0-9]

    RFC: [A-Z,Ñ,&]{3,4}[0-9]{2}[0-1][0-9][0-3][0-9][A-Z,0-9]?[A-Z,0-9]?[0-9,A-Z]?

    Lo pueden corroborar en: ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/cfd/iedu.pdf

    En la página 3

    ResponderEliminar
  9. Gracias por colaborar con esta informaciòn actualizare el Post con los datos que han aportado.

    Saludoss!

    ResponderEliminar
  10. Las expresion regular para el curp del link dado:
    ftp://ftp2.sat.gob.mx/asistencia_servicio_ftp/publicaciones/cfd/iedu.pdf

    No esta del todo bien, hay que considerar los meses y los dias, ya que acepta meses de 13-19 y dias de 32-39, como sabemos eso no exite.

    Deberian de tomarlo en cuenta para su codigo. Gracias

    ResponderEliminar