正则短语

以下正则表达式检查：

• 大写的前 3 个（道德人）或 4 个（自然人）字符。
• 有效日期（尽管为简化起见，未验证少于 31 天的月份）。
• 校验位是数字或字母 A。
• 允许部分之间使用连字符和/或空格。
• 捕获组中的每个部分。

/^([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])$/

全面验证

我用 JavaScript 发布代码以便能够在这里运行它，但是很容易将它移植到任何其他语言。

//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>

描述

以 RFC 的构建方式为参考：

1. 前 3-4 个字符取自([A-ZÑ&]{3,4}) ^{第 1 组}名称。
   • 父亲姓氏的首字母（或公司的首字母）。
   • 父姓的第一个内部元音（或公司的第二个首字母）。
     * 在这种情况下，我们可以验证它只是一个元音或“X”，但如果第一个姓有 1 或 2 个字母，则采用母姓的第一个字母（可以是辅音）。
     * 对于公司，如果他们没有 3 个单词，则取以下名字的字母。
   • 母亲姓氏的首字母（或公司的第三个首字母）。
   • 名称的首字母（公司没有，它们总共有 3 个字符）。
2. 可选空格或连字符?(?:- ?)?。
   接受：" ", "-", " -", " - ", "- ", 或没有连字符或空格。
   *_{该模式看起来很有趣，但它是：一个可选的空格，后跟一个可选的（未捕获的）组，这匹配一个连字符可选地后跟一个空格。如果您不想允许使用空格或连字符，则可以删除此模式。}
3. 出生日期（或公司成立日期）。
   (\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])) ^{第 2 组}。
   • \d{2}年。
   • (?:0[1-9]|1[0-2])月。
   • (?:0[1-9]|[12]\d|3[01])天。
     * 我接受最多 31 个月。我相信输入日期数据的错误将在稍后使用校验位进行验证。但是，如果您想更严格一些，尽管您可以在正则表达式中进行验证，但我建议您使用所使用的编程语言的功能来进行验证。
4. 可选空格或连字符?(?:- ?)?。
5. 2 个字母数字字符([A-Z\d]{2}) ^{组 3}的同音异位符。
6. 校验位（数字或字母 A）([A\d]) ^{组 4}。

使用正则表达式验证后，我们检查前 11 或 12 个字符的预期校验位是否与输入的校验位（最后一个字符）匹配。使用称为模块 11或ISBN 10的控制代码方法的改编。

我们已经对 RFC 的 4 个部分的文本进行了单独的捕获，rfcSinDigito它将是前 11 或 12 个字符，digitoVerificador它将是最后一个字符。

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

但如果它们是 11 个字符（道德人 - 公司的 RFC），则调整为能够对两者使用相同的算法。您可以在其前面加一个空格，或直接输入计算值。

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

要计算预期数字，首先将每个字符的索引从 13 加到 2，乘以 12 个字符中每个字符的值，这些字符的值按照以下顺序（字典）从 0 到 38：

0123456789ABCDEFGHIJKLMN&OPQRSTUVWXYZ Ñ

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

在加法之上，你取除以 11 的余数的 11 的补码（或模 11，因此该方法的名称）。

digitoEsperado = 11 - suma % 11;

0如果给出 10，则变为A。

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

现在是的，我们可以比较它们是否匹配以返回结果。

if (digitoVerificador != digitoEsperado)
    return false;

但是我们为通用 RFC 的特殊情况添加了 2 个例外（关于税务验证的问题和答案，第 5 点和第 6 点? ），它们不是自然人或法人的有效RFC ，但用于：
1. XAXX010101000::: 操作与公众一起进行。
2. XEXX010101000::: 对未在 RFC 中注册的国外居民进行的操作。

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

^{* 如您所见，我使用了可选的第二个参数 ( aceptarGenerico)，以防它们不被允许。}

最后，如果它通过了上述所有规则，则返回干净的 RFC 。

return rfcSinDigito + digitoVerificador;

RFC 验证算法

一个 RFC 当且仅当它满足以下 7 个条件时才有效：

1. RFC 必须正好有 12 或 13 个字符（12 个用于法人实体，13 个用于个人）。我们的用户界面可能允许您输入连字符、空格或其他分隔符。这里我只说构成 RFC 的字符，分隔符将在另一个层次上处理。
2. 名称的字符只能包含大写字母 AZ、符号 & 和 Ñ。对于 12 个字符的 RFC，名称是前 3 个字符，对于 13 个字符，名称是前 4 个字符。
3. 这个名字不方便。文档中有一个包含 41 个不方便名称的表格，例如 MOCO，一个有效的 RFC 不能有该名称。所有不方便的名称都是针对自然人的（它们都是四个字母），但是在检查时没有必要检查 RFC 的长度是否为 13 个字符。我们可以直接检查前四个，如果我们因为这个原因给道德人 RFC 不正确，结果将是有效的，因为只有当日期的第一个数字不是数字时才会发生这种情况，这将是不正确的 RFC。
4. 日期有效。日期是名称后面的 6 个字符。采用 YYMMDD 格式（年份的最后两位数字，月份 01 到 12，日期 01 到 31）。331403（一年中以 33 结尾的第 14 个月的第 3 个月）都无效。010229（以 01 结尾的一年的 2 月 29 日）也无效。
5. 第一个同音异义词是有效的。这是日期之后的第一个。它必须是从 A 到 V 的大写字母（包括两端）或从 1 到 9 的数字（包括两端），Ñ 和 0 无效。之所以如此，是因为在问题中出现的文档的“获得同音异义键的过程”部分中，有一个步骤是用 34 除以 3 位数字并查阅表格。999/34 = 29。在该表 29 中是字母 V
6. 同音的第二个区分特征是有效的。这是上一个之后的那个。由于遵循的过程，这可以是相应表中的任何字符，即从 A 到 Z 和从 1 到 9。Ñ 和 0 无效。该文档描述了如何计算 2 个同音异义字符，但这并不让我们感兴趣，因为我们只有 RFC 而没有产生这 2 个同音异义字符的名称。
7. 校验位必须正确。校验位是最后一位。它只能是 0 到 9 之间的数字或字母 A。它是根据 RFC 的其他字符计算的。此数字充当错误检测器代码，允许检测用户在输入 RFC 时所犯的大多数错误。

请注意，有效是指符合文档所有标准的 RFC，即生成该 RFC 的名称和出生日期或创建日期的组合。而对于无效的 RFC，没有最终生成该 RFC 的名称和日期。仅仅因为它有效并不意味着它存在。

校验位计算。

如果 RFC 有 12 个字符，我们会在开头添加一个空格。

我们使用 RFC 的所有字符，除了最后一个字符。也就是说，我们总是使用 12 个字符。
根据下表，每个字符对应一个值：

第一个字符的值乘以 13，第二个乘以 12，第三个乘以 11，以此类推，直到第十二个字符乘以 2。
所有这些值相加。此外，该文档还描述了一些不必要的复杂操作，相当于：

• 减去总和到 11000。您计算减法的模数 11。
• 如果模块的结果是10，则校验位为A。否则，与您获得的数字相同。

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.

正则短语

如果我要使用正则表达式作为预验证步骤，我会使用：

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

此表达式接受不正确的日期，例如 999999。既不存在第 99 天也不存在第 99 个月。
我认为使正则表达式复杂化没有任何意义，例如拒绝以 9 开​​头的日期，因为正则表达式仍不会检查日期（除非您使用非常复杂的正则表达式）。最好留下正则表达式的词法分析（查看字符是否有效）和其他级别的语义（查看日期是否正确）。但这值得商榷。

使用 Python 和库。

通常，实现某事的最佳方式是不去做，如果它可用且可靠，则使用现成的实现。教育目的或某些非常特殊的要求除外。

有几个库可以检查 RFC。例如来自 Arthur de Jong 和其他人的 stdnum。可在https://github.com/arthurdejong/python-stdnum在GNU Lesser General Public License版本 2.1 或更高版本下获得。

#!/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

没什么可评论的，图书馆已经完成了一切。

使用函数式编程。在规模

进行检查的函数是唯一公开的并且也被调用的函数esValido。与 Python 一样，true如果传递的 RFC 有效，它就会返回。
该代码包含解释其工作原理的注释。

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)
  }
}

观察

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.

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;
        }
}

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.

按照奥兰多·阿方索的答案，按照SAT SAT 2的逻辑。使用 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>

它适用于其他语言。这是一个例子。

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
} 

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>