¿Cómo validar un RFC de México y su digito verificador?

Question

Pregunta: ¿Cómo puedo verificar que el formato de un RFC mexicano sea válido?

¿Qué es el RFC? El Registro Federal de Contribuyentes (RFC) es una clave única que requiere toda persona física o moral en México para realizar cualquier actividad económica lícita. Es el código tributario de personas y empresas expedido por el SAT.

El RFC se genera a partir de las letras del nombre y los apellidos (personas), o de las siglas o las primeras letras del nombre y la fecha de creación (empresas). Las reglas de generación y validación están descriptas en el Algoritmo para generar el RFC con homoclave para personas fisicas y morales.odt .

Contexto: Quiero validar que un RFC podría ser válido. No me interesa ver si efectivamente existe. Implementé una validación muy genérica que permite que los últimos 3 dígitos sean opcionales:

/^[A-ZÑ&]{3,4}\d{6}(?:[A-Z\d]{3})?$/

pero ahora me interesa validar más estrictamente el RFC completo, viendo que el dígito verificador sea correcto (el último caracter).

Answer 1

Expresión regular

La siguiente expresión regular verifica:

• Los primeros 3 (persona moral) o 4 (persona física) caracteres en mayúsculas.
• Fecha válida (aunque para simplificarlo, no se están validando meses con menos de 31 días).
• El dígito verificador sea un dígito o una letra A.
• Permitiendo que haya guiones y/o espacios entre las partes.
• Capturando cada parte en un grupo.

/^([A-ZÑ&]{3,4}) ?(?:- ?)?(\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])) ?(?:- ?)?([A-Z\d]{2})([A\d])$/

Validación completa

Publico el código en JavaScript para poder correrlo acá, pero es muy sencillo de llevar a cualquier otro lenguaje.

//Función para validar un RFC
// Devuelve el RFC sin espacios ni guiones si es correcto
// Devuelve false si es inválido
// (debe estar en mayúsculas, guiones y espacios intermedios opcionales)
function rfcValido(rfc, aceptarGenerico = true) {
    const re       = /^([A-ZÑ&]{3,4}) ?(?:- ?)?(\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])) ?(?:- ?)?([A-Z\d]{2})([A\d])$/;
    var   validado = rfc.match(re);

    if (!validado)  //Coincide con el formato general del regex?
        return false;

    //Separar el dígito verificador del resto del RFC
    const digitoVerificador = validado.pop(),
          rfcSinDigito      = validado.slice(1).join(''),
          len               = rfcSinDigito.length,

    //Obtener el digito esperado
          diccionario       = "0123456789ABCDEFGHIJKLMN&OPQRSTUVWXYZ Ñ",
          indice            = len + 1;
    var   suma,
          digitoEsperado;

    if (len == 12) suma = 0
    else suma = 481; //Ajuste para persona moral

    for(var i=0; i<len; i++)
        suma += diccionario.indexOf(rfcSinDigito.charAt(i)) * (indice - i);
    digitoEsperado = 11 - suma % 11;
    if (digitoEsperado == 11) digitoEsperado = 0;
    else if (digitoEsperado == 10) digitoEsperado = "A";

    //El dígito verificador coincide con el esperado?
    // o es un RFC Genérico (ventas a público general)?
    if ((digitoVerificador != digitoEsperado)
     && (!aceptarGenerico || rfcSinDigito + digitoVerificador != "XAXX010101000"))
        return false;
    else if (!aceptarGenerico && rfcSinDigito + digitoVerificador == "XEXX010101000")
        return false;
    return rfcSinDigito + digitoVerificador;
}


//Handler para el evento cuando cambia el input
// -Lleva la RFC a mayúsculas para validarlo
// -Elimina los espacios que pueda tener antes o después
function validarInput(input) {
    var rfc         = input.value.trim().toUpperCase(),
        resultado   = document.getElementById("resultado"),
        valido;
        
    var rfcCorrecto = rfcValido(rfc);   // ⬅️ Acá se comprueba
  
    if (rfcCorrecto) {
     valido = "Válido";
      resultado.classList.add("ok");
    } else {
     valido = "No válido"
     resultado.classList.remove("ok");
    }
        
    resultado.innerText = "RFC: " + rfc 
                        + "\nResultado: " + rfcCorrecto
                        + "\nFormato: " + valido;
}

#resultado {
    background-color: red;
    color: white;
    font-weight: bold;
}
#resultado.ok {
    background-color: green;
}

<label>RFC:</label>
<input type="text" id="rfc_input" style="width:100%;"
       oninput="validarInput(this)" 
       placeholder="Ingrese su RFC">
<pre id="resultado"></pre>

Descripción

Tomando como referencia la forma en que se construye el RFC:

1. Los primeros 3-4 caracteres se toman del nombre ([A-ZÑ&]{3,4}) ^{Grupo 1}.
   • Inicial del apellido paterno (o primera inicial de la empresa).
   • Primera vocal interna del apellido paterno (o segunda inicial de la empresa).
     * En este caso, podríamos haber validado que sea sólo una vocal o una "X", pero si el primer apellido tiene 1 o 2 letras, se toma la primera letra del apellido materno (puede ser una consonante).
     * Para las empresas, si no tienen 3 palabras, se toman las siguientes letras del primer nombre.
   • Inicial del apellido materno (o tercera inicial de la empresa).
   • Inicial del nombre (nada para empresas, tienen 3 caracteres en total).
2. Espacios o guiones opcionales ?(?:- ?)?.
   Acepta: " ", "-", " -", " - ", "- ", o sin guiones ni espacios.
   * _{El patrón se ve gracioso pero es: un espacio opcional, seguido de un grupo opcional (sin capturar), éste coincide con un guión seguido opcionalmente de un espacio. Si no se quiere permitir espacios ni guiones, se puede eliminar este patrón.}
3. La fecha de nacimiento (o de creación de la empresa).
   (\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])) ^{Grupo 2}.
   • \d{2} año.
   • (?:0[1-9]|1[0-2]) mes.
   • (?:0[1-9]|[12]\d|3[01]) día.
     * Estoy aceptando hasta 31 para cualquier mes. Considero que un error al ingresar los datos de la fecha se validaría más adelante con el dígito verificador. No obstante, si se quisiera ser más estricto, y aunque se podría validar en la expresión regular, recomendaría hacerlo con las funciones del lenguaje de programación utilizado.
4. Espacios o guiones opcionales ?(?:- ?)?.
5. Homoclave de 2 caracteres alfanuméricos ([A-Z\d]{2}) ^{Grupo 3}.
6. Dígito verificador (dígito o letra A) ([A\d]) ^{Grupo 4}.

Luego de validar con el regex, comprobamos que el dígito verificador esperado para los primeros 11 o 12 caracteres coincida con el dígito verificador ingresado (el último caracter). Se utiliza una adaptación del método para códigos de control llamado Módulo 11 o ISBN 10.

Ya tenemos capturas por separado del texto de las 4 partes del RFC, en donde rfcSinDigito serán los primeros 11 o 12 caracteres y digitoVerificador será el último caracter.

//Separar el dígito verificador del resto del RFC
const digitoVerificador = validado.pop(),
      rfcSinDigito      = validado.slice(1).join(''),

Pero si son 11 caracteres (RFC de persona moral -empresa), se lo ajusta para poder usar el mismo algoritmo para ambos. Se lo puede preceder con un espacio, o directamente ingresar el valor calculado.

if (len == 12) suma = 0
else suma = 481; //Ajuste para persona moral

Para calcular el dígito esperado, primero se suma el índice de cada caracter desde 13 hasta 2, multiplicado por el valor de cada uno de los 12 caracteres, los cuales tienen un valor de 0 a 38 según este orden (diccionario):

0123456789ABCDEFGHIJKLMN&OPQRSTUVWXYZ Ñ

for(var i=0; i<len; i++)
    suma = suma + diccionario.indexOf(rfcSinDigito.charAt(i)) * (indice - i);

Y sobre la suma, se toma el complemento a 11 del resto de dividir por 11 (o módulo 11, de ahí el nombre del método).

digitoEsperado = 11 - suma % 11;

Si da 11, se convierte en 0. Si da 10, se convierte en A.

if (digitoEsperado == 11) digitoEsperado = 0;
else if (digitoEsperado == 10) digitoEsperado = "A";

Ahora sí, podemos comparar si coinciden para devolver el resultado.

if (digitoVerificador != digitoEsperado)
    return false;

Pero agregamos 2 excepciones, para los casos especiales de RFCs genéricos (Preguntas y respuestas sobre Comprobación Fiscal, puntos 5 y 6 ), que no son RFCs válidos de personas físicas o morales, pero se utilizan para:
1. XAXX010101000 ::: Operaciones efectuadas con público en general.
2. XEXX010101000 ::: Operaciones efectuadas con residentes en el extranjero que no se encuentren inscritos en el RFC.

if ((digitoVerificador != digitoEsperado)
 && (!aceptarGenerico || rfcSinDigito + digitoVerificador != "XAXX010101000"))
    return false;
else if (!aceptarGenerico && rfcSinDigito + digitoVerificador == "XEXX010101000")
    return false;

^{* Como se ve, estoy usando un segundo parámetro opcional (aceptarGenerico), en caso de que no se permitan.}

Finalmente, si pasó todas las reglas anteriores, se devuelve el RFC limpio.

return rfcSinDigito + digitoVerificador;

Answer 2

Algoritmo de validación de RFC

Un RFC es válido si y solo si cumple las siguientes 7 condiciones:

1. El RFC debe tener exactamente 12 o 13 carácteres (12 para personas morales y 13 para personas físicas). Es posible que nuestra interfaz de usuario permita introducir guiones, espacios u otros carácteres separadores. Aquí hablo solo de los carácteres que componen el RFC, los separadores se tratarían a otro nivel.
2. Los carácteres del nombre pueden solo contener las letras mayúsculas A-Z, el símbolo & y la Ñ. Para RFC de 12 carácteres el nombre son los 3 primeros y para 13 son los 4 primeros.
3. El nombre no es inconveniente. Hay una tabla con 41 nombres inconvenientes en el documento, por ejemplo MOCO, un RFC valido no puede tener ese nombre. Todos los nombres inconvenientes son para personas físicas (son todos de cuatro letras) pero al hacer la comprobación no es necesario comprobar que el RFC sea de 13 carácteres. Podemos comprobar contra los cuatro primeros directamente, si diésemos como incorrecto un RFC de persona moral por este motivo el resultado sería válido porque esto solo puede suceder si el primer dígito de la fecha no es una cifra, que sería un RFC incorrecto.
4. La fecha es válida. La fecha son los 6 carácteres que siguen al nombre. En formato AAMMDD ( dos últimas cifras del año, mes 01 a 12 y día 01 a 31). No sería válido ni 331403 (3 del mes 14 de algún año acabado en 33). Tampoco sería válido 010229 (29 de febrero de algún año acabado en 01).
5. El primer carácter diferenciador de homonimia es válido.Este es el primero que sigue a la fecha. Debe ser una letra mayúscula de la A a la V, ambas inclusive, o una cifra del 1 al 9 ambas inclusive, la Ñ y el 0 no son válidas. Esto es así porque en el apartado PROCEDIMIENTO PARA OBTENER LA CLAVE DIFERENCIADORA DE HOMONIMIA del documento que figura en la pregunta hay un paso en que se divide un número de 3 cifras entre 34 y se consulta una tabla. 999/34 = 29 . En esa tabla el 29 es la letra V
6. El segundo carácter diferenciador de homonimia es válido. Este es el que sigue al anterior. Debido al procedimiento que se sigue este puede ser cualquier carácter de la tabla correspondiente, es decir, de la A a la Z y del 1 al 9. La Ñ y el 0 no son válidos. El documento describe cómo se calculan los 2 carácteres diferenciadores de homonimia, pero esto no nos interesa porque solo disponemos del RFC y no del nombre que dio lugar a esos 2 carácteres diferenciadores de homonimia.
7. El dígito Verificador debe ser correcto. El dígito verificador es el último. Solo puede ser una cifra del 0 al 9 o la letra A. Y se calcula en función de los otros carácteres del RFC. Este dígito actúa como un código detector de errores que permite detectar la mayoría de errores cometidos por usuarios al introducir un RFC.

Nótese que por válido nos referimos a un RFC que cumple todas las normas del documento, es decir, existe una combinación de nombre y fecha de nacimiento o creación que genera ese RFC. Mientras que para un RFC inválido no hay ningún nombre y fecha que acabe generando ese RFC. Que sea válido no significa que exista.

Cálculo del dígito de verificación.

Si el RFC tiene 12 carácteres añadimos un espacio en blanco al principio.

Usamos todos los carácteres del RFC excepto el último. Es decir, usamos 12 carácteres siempre.
Cada carácter se corresponde con un valor según la siguiente tabla:

El valor del primer carácter se multiplica por 13, el segundo por 12, el tercero por 11 y así sucesivamente hasta el carácter duodécimo que se multiplica por 2.
Todos estos valores se suman. Y con la suma el documento describe unas operaciones innecesariamente complicadas que son equivalentes a :

• A 11000 le restas la suma. Calculas el módulo 11 de la resta.
• Si el resultado del módulo es 10 el dígito verificador es la A. En otro caso es el mismo número que has obtenido.

Ejemplo para el RFC GODE561231GR8

Carácter Valor Multiplicador  Resultado
    G     16  *     13      =    208       
    O     25  *     12      =    300 
    D     13  *     11      =    143
    E     14  *     10      =    140
    5      5  *      9      =     45
    6      6  *      8      =     48
    1      1  *      7      =      7
    2      2  *      6      =     12
    3      3  *      5      =     15
    1      1  *      4      =      4
    G     16  *      3      =     48
    R     28  *      2      =     56
-------------------------------------
                         SUMA : 1026
( 11000 - 1026 ) % 11 = 8 -> El dígito verificador es 8
El RFC es Válido.

Expresión Regular

Si fuese a utilizar una expresión regular como paso previo a la validación usaría :

[A-ZÑ&]{3,4}\d{6}[A-V1-9][A-Z1-9][0-9A]

Esta expresión acepta fechas incorrectas como 999999. Ni el día 99 ni el mes 99 existen.
No le veo sentido al complicar el regex, para rechazar los días que empiecen por 9 por ejemplo, puesto que de todas formas se van a quedar fechas no comprobadas por el regex (salvo que use un regex muy complicado). Es mejor dejar el análisis léxico para los regex (ver si los carácteres son válidos) y el semántico para otros niveles (ver si la fecha es correcta). Pero esto es opinable.

Usando Python y una biblioteca.

Con frecuencia la mejor manera de implementar algo es no hacerlo y usar una implementación ya hecha si está disponible y es fiable. Salvo para fines educativos o ciertos requisitos muy especiales.

Hay varias librerías que comprueban un RFC. Por ejemplo stdnum de Arthur de Jong and others. Disponible en https://github.com/arthurdejong/python-stdnum bajo licencia GNU Lesser General Public License versión 2.1 o posterior.

#!/usr/bin/env python
from stdnum.mx.rfc import (validate,InvalidComponent,InvalidFormat,
InvalidLength,InvalidChecksum)

# Devuelve true si el RFC pasado es valido
# rfc es un string
def esValido(rfc):
  try:
    validate( rfc, validate_check_digits=True)
    return True
  except (InvalidComponent,InvalidFormat,InvalidLength,InvalidChecksum):
    return False

Poco hay que comentar, ya viene todo hecho por la biblioteca.

Usando programación funcional. En Scala

La función que hace la comprobación es la única pública y también se llama esValido. Al igual que la de Python devuelve true si el RFC pasado es válido.
El código incluye comentarios que explican su funcionamiento.

object RFCcheck extends  App {
  private val caracteres = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

  // Estos son los carácteres permitidos en las 3 primeras posiciones (personas
  // morales, longitud total RFC es 12) o las 4 primeras posiciones (personas
  // físicas, longitud total RFC es 3)
  private val caracteresPrimeraParte = caracteres + "Ñ&"

  // Cifras permitidas en los 6 carácteres de la fecha
  private val cifras = "0123456789"

  // Carácteres permitidos en el dígito validador
  private val caracteresValidador = cifras + "A"

  // Valores permitidos para los carácteres primero y segundo de la clave
  // diferenciadora de la homonimia
  // Estos valores estan en la tabla del anexo 2
  // Nótese que el primer carácter se obtiene dividiendo un numero de 3 cifras
  // entre 34
  // 999/34 = 29 . Por tanto el máximo carácter en ese caso es 'V'
  private val caracteresHomonimia1 = "123456789ABCDEFGHIJKLMNOPQRSTUV"
  private val caracteresHomonimia2 = caracteresHomonimia1 + "WXYZ"

  // Comprobar que la fecha es valida
  // Por ejemplo, no permitir el 97 de octubre o el mes 17
  // Nótese que se permite el 29 de febrero de los años acabados en 00
  //porque el año 2100 no tendrá ese día pero el 2000 sí lo tuvo
  private val maxDiaMes = -1::31::28::31::30::31::30::31::31::30::31::30::31::
    Nil
  private def fechaValida( s:String ):Boolean = {
    val anyo = s.substring( 0, 2).toInt
    val mes  = s.substring( 2, 4).toInt
    val dia  = s.substring( 4, 6).toInt
    if ( mes<1 || mes>12 ) return false
    if ( dia<1 ) return false
    if ( anyo%4==0 && mes==2 ) return dia<=29
    dia<=maxDiaMes(mes)
  }

  // Carácteres en el orden de la tabla del anexo 3. Su posición es igual al
  // valor que se les asigna en la tabla del Anexo 3
  private val tablaAnexo3 = "0123456789ABCDEFGHIJKLMN&OPQRSTUVWXYZ Ñ"

  // Cálculo del dígito verificador
  private def calculaDigitoVerificador( rfc:String ):Char = {
    // Usar el rfc sin el último carácter que es el verificador
    // Para las personas morales se añade un espacio al principio
    val rfcSinDigitoV = if (rfc.length==13 ) rfc.substring(0,12)
    else " " +rfc.substring(0,11)
    // Para cada carácter multiplicamos su valor por (13 - posicion)
    // Y calculamos la suma de todas esas multiplicaciones
    val suma = (0 until 12 zip rfcSinDigitoV) .
      foldLeft (0) ( (acu,p) => acu + tablaAnexo3.indexOf(p._2) * (13-p._1) )
    // Y calculamos el dígito verificador (11000-suma) módulo 11.
    // caracteresValidador tiene los carácteres en el orden que
    // necesitamos del 0 al 10 (el décimo es la A)
    caracteresValidador( (11000-suma) % 11)
  }

  // Palabras no permitidas según el anexo 4
  private val palabrasInconvenientes = "BUEI"::"BUEY"::"CACA"::"CACO"::"CAGA"::
    "CAGO"::"CAKA"::"CAKO"::"COGE"::"COJA"::"COJE"::"COJI"::"COJO"::"CULO"::
    "FETO"::"GUEY"::"JOTO"::"KACA"::"KACO"::"KAGA"::"KAGO"::"KOGE"::"COJO"::
    "KAKA"::"KULO"::"MAME"::"MAMO"::"MEAR"::"MEAS"::"MEON"::"MION"::"MOCO"::
    "MULA"::"PEDA"::"PEDO"::"PENE"::"PUTA"::"PUTO"::"QULO"::"RATA"::"RUIN"::
    Nil

  // Calcula si es válido un rfc
  // El RFC debe tener exáctamente 12 carácteres para personas morales
  // Y 13 carácteres para personas físicas
  // No se admiten separadores como espacios o guiones
  def esValido( rfc:String ):Boolean = {
    val nombre = rfc.substring(0, rfc.length - 9) // Primeros 3 o 4 carácteres
    val fecha  = rfc.substring(rfc.length - 9, rfc.length - 3) // 6 carácteres
    val homonimia1 = rfc(rfc.length-3) // 1º char de clave dif de homonimia
    val homonimia2 = rfc(rfc.length-2) // 2º char de clave dif de homonimia
    val digitoVerificador = rfc(rfc.length-1) // Último carácter
    // Un RFC es válido si se cumple todo lo siguiente:
    (rfc.length == 12 || rfc.length == 13) && // 12 o 13 de longitud
      // Solo carácteres permitidos en nombre
      nombre.foldLeft(true)(_ && caracteresPrimeraParte.contains(_)) &&
      // Solo carácteres permitidos en fecha
      fecha. foldLeft(true)(_ && cifras.contains(_)) &&
      // Solo carácteres permitidos en clave diferenciadora de homonimia
      caracteresHomonimia1.contains(homonimia1) &&
      caracteresHomonimia2.contains(homonimia2) &&
      // La fecha es valida
      fechaValida(fecha) &&
      // Nombre no es una palabra inconveniente
      !palabrasInconvenientes.contains(nombre) &&
      // El digito verificador es correcto
      digitoVerificador == calculaDigitoVerificador(rfc)
  }
}

Observaciones

En el documento Algoritmo para generar el RFC con homoclave para personas fisicas y morales.odt en la regla 9ª de la sección 2.2 figuran 39 palabras inconvenientes que no se pueden usar en un RFC. Sin embargo en el Anexo 4 figuran 41 palabras. Las 2 palabras extra son CAKO y MEAS. Yo he supuesto que el anexo es el correcto.

He probado con un millón de RFCs aleatorios, correctos e incorrectos, y las dos implementaciones han dado el mismo resultado en todos los casos. Aunque esto tampoco es garantía de nada.

No doy como buenos XEXX010101000 ni XAXX010101000 porque en el documento no se mencionan. La biblioteca de python hace lo mismo. Caso de que fuese necesario darlos como buenos es trivial hacer la modificación.

Answer 3

Ingresando a la pagina del SAT https://portalsat.plataforma.sat.gob.mx/ConsultaRFC/ pude obtener la expresión regular y la función que ellos utilizán espero les sirva:

// patron del RFC, persona moral
_rfc_pattern_pm = "^(([A-ZÑ&]{3})([0-9]{2})([0][13578]|[1][02])(([0][1-9]|[12][\\d])|[3][01])([A-Z0-9]{3}))|" +
                  "(([A-ZÑ&]{3})([0-9]{2})([0][13456789]|[1][012])(([0][1-9]|[12][\\d])|[3][0])([A-Z0-9]{3}))|" +
                  "(([A-ZÑ&]{3})([02468][048]|[13579][26])[0][2]([0][1-9]|[12][\\d])([A-Z0-9]{3}))|" +
                  "(([A-ZÑ&]{3})([0-9]{2})[0][2]([0][1-9]|[1][0-9]|[2][0-8])([A-Z0-9]{3}))$";
 // patron del RFC, persona fisica
 _rfc_pattern_pf = "^(([A-ZÑ&]{4})([0-9]{2})([0][13578]|[1][02])(([0][1-9]|[12][\\d])|[3][01])([A-Z0-9]{3}))|" +
                       "(([A-ZÑ&]{4})([0-9]{2})([0][13456789]|[1][012])(([0][1-9]|[12][\\d])|[3][0])([A-Z0-9]{3}))|" +
                       "(([A-ZÑ&]{4})([02468][048]|[13579][26])[0][2]([0][1-9]|[12][\\d])([A-Z0-9]{3}))|" +
                       "(([A-ZÑ&]{4})([0-9]{2})[0][2]([0][1-9]|[1][0-9]|[2][0-8])([A-Z0-9]{3}))$";

function ValidaRFC(){
    var rfc = document.getElementById("ConsultaForm:rfc").value;
    if (rfc.match(_rfc_pattern_pm) || rfc.match(_rfc_pattern_pf)){
            alert("La estructura de la clave de RFC es valida");
            return true;
        }else {
            alert("La estructura de la clave de RFC es incorrecta.");
            return false;
        }
}

Answer 4

API gratuita

API open source siempre gratuita con un tiempo de respuesta de 600 ms y en 2 pasos para verificar el rfc, saber si esta en la lista negra del SAT y en LRFC: Documentacion.

Expresión regular

La siguiente expresión regular (en el codigo) verifica:

• De manera individual a la persona moral y a la persona fisica.
• Si acepta XAXX010101000 y XEXX010101000
• Si acepta AAAA0101010A8, AAAA010101AZ3 y MOCO010101AA9, pero el SAT en su sistema busca en su base de datos y devuelve "RFC no registrado en el padrón de contribuyentes". Es decir, no estan en LRFC.

Seguiendo la logica de SAT SAT 2 por la respuesta Orlando Alfonso. Usando el codigo ejemplo de Mariano.

//Función para validar un RFC
// Devuelve el RFC sin espacios ni guiones si es correcto
// Devuelve false si es inválido
// (debe estar en mayúsculas, guiones y espacios intermedios opcionales)
function rfcValido(rfc, aceptarGenerico = true) {
     _rfc_pattern_pm = "^(([A-ZÑ&]{3})([0-9]{2})([0][13578]|[1][02])(([0][1-9]|[12][\\d])|[3][01])([A-Z0-9]{3}))|" +
              "(([A-ZÑ&]{3})([0-9]{2})([0][13456789]|[1][012])(([0][1-9]|[12][\\d])|[3][0])([A-Z0-9]{3}))|" +
              "(([A-ZÑ&]{3})([02468][048]|[13579][26])[0][2]([0][1-9]|[12][\\d])([A-Z0-9]{3}))|" +
              "(([A-ZÑ&]{3})([0-9]{2})[0][2]([0][1-9]|[1][0-9]|[2][0-8])([A-Z0-9]{3}))$";
 _rfc_pattern_pf = "^(([A-ZÑ&]{4})([0-9]{2})([0][13578]|[1][02])(([0][1-9]|[12][\\d])|[3][01])([A-Z0-9]{3}))|" +
                   "(([A-ZÑ&]{4})([0-9]{2})([0][13456789]|[1][012])(([0][1-9]|[12][\\d])|[3][0])([A-Z0-9]{3}))|" +
                   "(([A-ZÑ&]{4})([02468][048]|[13579][26])[0][2]([0][1-9]|[12][\\d])([A-Z0-9]{3}))|" +
                   "(([A-ZÑ&]{4})([0-9]{2})[0][2]([0][1-9]|[1][0-9]|[2][0-8])([A-Z0-9]{3}))$";
   return rfc.match(_rfc_pattern_pm) || rfc.match(_rfc_pattern_pf);
}


//Handler para el evento cuando cambia el input
// -Lleva la RFC a mayúsculas para validarlo
// -Elimina los espacios que pueda tener antes o después
function validarInput(input) {
    var rfc         = input.value.trim().toUpperCase(),
        resultado   = document.getElementById("resultado"),
        valido;
        
    var rfcCorrecto = rfcValido(rfc);   // ⬅️ Acá se comprueba
  
    if (rfcCorrecto) {
        valido = "Válido";
      resultado.classList.add("ok");
    } else {
        valido = "No válido"
        resultado.classList.remove("ok");
    }
        
    resultado.innerText = "RFC: " + rfc
                        + "\nFormato: " + valido;
}

#resultado {
    background-color: red;
    color: white;
    font-weight: bold;
}
#resultado.ok {
    background-color: green;
}

<label>RFC:</label>
<input type="text" id="rfc_input" style="width:100%;"
       oninput="validarInput(this)" 
       placeholder="Ingrese su RFC">
<pre id="resultado"></pre>

Funciona en otros lenguajes. Aqui un ejemplo en go.

func ensureRFC(rfc string) bool {
    naturalPerson, _ := regexp.MatchString("^(([A-ZÑ&]{4})([0-9]{2})([0][13578]|[1][02])(([0][1-9]|[12][\\d])|[3][01])([A-Z0-9]{3}))|(([A-ZÑ&]{4})([0-9]{2})([0][13456789]|[1][012])(([0][1-9]|[12][\\d])|[3][0])([A-Z0-9]{3}))|(([A-ZÑ&]{4})([02468][048]|[13579][26])[0][2]([0][1-9]|[12][\\d])([A-Z0-9]{3}))|(([A-ZÑ&]{4})([0-9]{2})[0][2]([0][1-9]|[1][0-9]|[2][0-8])([A-Z0-9]{3}))$", 
    rfc)
    legalPerson, _ := regexp.MatchString("^(([A-ZÑ&]{3})([0-9]{2})([0][13578]|[1][02])(([0][1-9]|[12][\\d])|[3][01])([A-Z0-9]{3}))|(([A-ZÑ&]{3})([0-9]{2})([0][13456789]|[1][012])(([0][1-9]|[12][\\d])|[3][0])([A-Z0-9]{3}))|(([A-ZÑ&]{3})([02468][048]|[13579][26])[0][2]([0][1-9]|[12][\\d])([A-Z0-9]{3}))|(([A-ZÑ&]{3})([0-9]{2})[0][2]([0][1-9]|[1][0-9]|[2][0-8])([A-Z0-9]{3}))$", 
    rfc)
    return !naturalPerson && !legalPerson
} 

Answer 5

Actualmente ocupo esta expresion regular, valida lo siguiente:

• 10 Digitos (sin homoclave)
• 12 Digitos (moral)
• 13 Digitos

/^[a-zA-Z]{3,4}(\d{6})((\D|\d){2,3})?$/

function validaRFC(){
  let pattern = /^[a-zA-Z]{3,4}(\d{6})((\D|\d){2,3})?$/;
  let rfc = document.getElementById("rfc").value;
  document.getElementById("estatus").innerHTML = pattern.test(rfc);
}

<input id="rfc" type="text" onkeyup="validaRFC()"/>
<label id="estatus"></label>