Home / Questions / 31713
Accepted
Mariano
Asked: 2020-11-05 00:32:05 +0800 CST 2020-11-05 00:32:05 +0800 CST

Как проверить RFC Мексики и его проверочную цифру?

  • 772

Вопрос: Как проверить правильность формата мексиканского RFC?

Что такое РФЦ? Федеральный реестр налогоплательщиков (RFC) — это уникальный ключ, который требуется каждому физическому или юридическому лицу в Мексике для осуществления любой законной экономической деятельности. Это налоговый кодекс для физических лиц и компаний, выпущенный SAT .

RFC формируется из букв имени и фамилии (физические лица), либо из инициалов или первых букв имени и даты создания (компании). Правила генерации и проверки описаны в Алгоритме генерации RFC с помощью гомоклава для физических и юридических лиц.odt ? .

Контекст: я хочу подтвердить, что RFC может быть действительным. Меня не интересует, существует ли он на самом деле. Я реализовал очень общую проверку, которая позволяет сделать последние 3 цифры необязательными:

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

но теперь я заинтересован в более строгой проверке полного RFC, чтобы убедиться, что контрольная цифра верна (последний символ).

regex

5 Answers

  1. Best Answer

    Обычная фраза

    Следующие проверки регулярных выражений:

    • Первые 3 (физическое лицо) или 4 (физическое лицо) символы в верхнем регистре.
    • Действительная дата (хотя для упрощения месяцы, в которых меньше 31 дня, не проверяются).
    • Контрольная цифра — это либо цифра, либо буква А.
    • Допускается использование дефисов и/или пробелов между частями.
    • Захват каждой части в группе.
    /^([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:

    4 буквы имени и фамилии - дата рождения - гомоклав


    1. Первые 3-4 символа берутся из названия ([A-ZÑ&]{3,4}) группы 1 .
      • Инициал фамилии отца (или первый инициал компании).
      • Первая внутренняя гласная отцовской фамилии (или второй инициал фирмы).
        * В этом случае мы могли бы подтвердить, что это только гласная или «Х», но если в первой фамилии 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\d]) Группа 4 .


    После проверки с помощью регулярного выражения мы проверяем, соответствует ли ожидаемая контрольная цифра для первых 11 или 12 символов введенной контрольной цифре (последний символ). Используется адаптация метода для контрольных кодов, называемая Module 11 или ISBN 10 .

    У нас уже есть отдельные захваты текста 4-х частей RFC, где 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;

    Если он дает 11, он становится 0. Если он дает 10, он становится A.

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


    Теперь да, мы можем сравнить, совпадают ли они, чтобы вернуть результат.

    if (digitoVerificador != digitoEsperado)
    return false;

    Но мы добавляем 2 исключения, для особых случаев общих RFC ( Вопросы и ответы по налоговой проверке, пункты 5 и 6 ? ), которые не являются действительными RFC физических или юридических лиц, но используются для:
    1. XAXX010101000::: Операции проводится с широкой публикой.
    2. XEXX010101000::: Операции, проводимые с резидентами за рубежом, не зарегистрированными в РФЦ.

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

    * Как видите, я использую необязательный второй параметр ( aceptarGenerico), если он не разрешен.


    Наконец, если он соответствует всем вышеуказанным правилам, возвращается чистый RFC .

    return rfcSinDigito + digitoVerificador;
    • 58

  2. Алгоритм проверки RFC

    RFC действителен тогда и только тогда, когда он соответствует следующим 7 условиям:

    1. В RFC должно быть ровно 12 или 13 символов (12 для юридических лиц и 13 для физических). Наш пользовательский интерфейс может позволять вам вводить дефисы, пробелы или другие символы-разделители. Здесь я говорю только о символах, составляющих RFC, разделители будут рассматриваться на другом уровне.
    2. Символы имени могут содержать только заглавные буквы AZ, символ & и Ñ. Для RFC из 12 символов имя — это первые 3, а для 13 — первые 4.
    3. Имя не неудобное. В документе есть таблица с 41 неудобным названием, например MOCO, валидный RFC не может иметь такое имя. Все неудобные имена для физических лиц (они все четырехбуквенные), но при проверке не обязательно проверять, что RFC имеет длину 13 символов. Мы можем проверить первые четыре напрямую, если бы мы дали моральному человеку RFC как неправильный по этой причине, результат был бы действительным, потому что это может произойти только в том случае, если первая цифра даты не является числом, что было бы неправильный RFC.
    4. Дата актуальна. Дата — это 6 символов, которые следуют за именем. В формате ГГММДД (последние две цифры года, месяц с 01 по 12 и день с 01 по 31). Ни 331403 (3 14-го месяца года, оканчивающегося на 33) не будет действительным. Также не будет действительным число 010229 (29 февраля года, оканчивающегося на 01).
    5. Действителен первый дифференциатор омонимии, первый после даты. Это должна быть заглавная буква от A до V, обе включительно, или цифра от 1 до 9, обе включительно, Ñ и 0 недействительны. Это так, потому что в разделе ПРОЦЕДУРА ПОЛУЧЕНИЯ ДИФФЕРЕНЦИРУЮЩЕГО КЛЮЧА ОМОНИМИИ документа, фигурирующего в вопросе, есть шаг, в котором трехзначное число делится на 34 и сверяется с таблицей. 999/34 = 29. В той таблице 29 стоит буква В
    6. Второй отличительный признак омонимии действителен. Это тот, который следует за предыдущим. В соответствии с процедурой это может быть любой символ из соответствующей таблицы, то есть от A до Z и от 1 до 9. Ñ и 0 недействительны. В документе описывается, как рассчитываются 2 отличительных признака омонимии, но это нас не интересует, потому что у нас есть только RFC, а не имя, которое дало начало этим 2 отличительным признакам омонимии.
    7. Контрольная цифра должна быть правильной. Контрольная цифра является последней. Это может быть только цифра от 0 до 9 или буква А. И рассчитывается она на основе остальных символов RFC. Эта цифра действует как код детектора ошибок, который позволяет обнаружить большинство ошибок, допущенных пользователями при вводе RFC.

    Обратите внимание, что под действительным мы подразумеваем RFC, который соответствует всем стандартам документа, то есть существует комбинация имени и даты рождения или создания, которая генерирует этот RFC. В то время как для недопустимого RFC нет имени и даты, которые в конечном итоге приводят к созданию этого RFC. Просто потому, что он действителен, не означает, что он существует.

    Расчет контрольной цифры.

    Если в RFC 12 символов, мы добавляем пробел в начале.

    Мы используем все символы RFC, кроме последнего. То есть мы всегда используем 12 символов.
    Каждый символ соответствует значению согласно следующей таблице:

    введите описание изображения здесь

    Значение первого символа умножается на 13, второго на 12, третьего на 11 и так далее, пока двенадцатый символ не будет умножен на 2.
    Все эти значения складываются вместе. Кроме того, в документе описаны некоторые излишне сложные операции, эквивалентные:

    • До 11000 вычитаете сумму. Вы вычисляете модуль 11 вычитания.
    • Если результат модуля равен 10, контрольной цифрой является A. В противном случае это то же число, которое вы получили.

    Пример для RFCGODE561231GR8

    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. Например 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.

    • 12

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

  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.

    Следуя логике SAT SAT 2 по ответу Орландо Альфонсо. Используя пример кода Мариано. 

    //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
}
    • 1

  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>

    • 0