¿Hay una expresión regular para detectar una expresión regular válida?

Question

¿Es posible detectar una expresión regular válida con otra expresión regular? Si es así, por favor da el código de ejemplo a continuación.

Answer 1

/ 
^            # start of string 
(           # first group start 
    (?: 
    (?:[^?+*{}()[\]\\|]+      # literals and ^, $ 
    | \\.         # escaped characters 
    | \[ (?: \^?\\. | \^[^\\] | [^\\^])  # character classes 
      (?: [^\]\\]+ | \\.)* \] 
    | \((?:\?[:=!]|\?<[=!]|\?>)? (?1)?? \) # parenthesis, with recursive content 
    | \(\? (?:R|[+-]?\d+) \)     # recursive matching 
    ) 
    (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]?)? # quantifiers 
    | \|          # alternative 
)*           # repeat content 
)            # end first group 
$            # end of string 
/

Esta es una expresión regular recursiva, y no es compatible con muchos motores de expresiones regulares. Los basados ​​en PCRE deberían ser compatibles.

Sin espacios en blanco y comentarios:

/^((?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>)?(?1)??\)|\(\?(?:R|[+-]?\d+)\))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*)$/ 

---

.NET no admite recursión directa. (. Los (?1) y (?R) construcciones) La recursión tendría que ser convertido en grupos equilibrados de conteo:

^           # start of string 
(?: 
    (?: [^?+*{}()[\]\\|]+     # literals and ^, $ 
    | \\.         # escaped characters 
    | \[ (?: \^?\\. | \^[^\\] | [^\\^]) # character classes 
     (?: [^\]\\]+ | \\.)* \] 
    | \((?:\?[:=!] 
     | \?<[=!] 
     | \?> 
     | \?<[^\W\d]\w*> 
     | \?'[^\W\d]\w*' 
     )?        # opening of group 
    (?<N>)        # increment counter 
    | \)         # closing of group 
    (?<-N>)        # decrement counter 
    ) 
    (?: (?:[?+*]|\{\d+(?:,\d*)?\}) [?+]?)? # quantifiers 
| \|          # alternative 
)*          # repeat content 
$           # end of string 
(?(N)(?!))        # fail if counter is non-zero. 

compactado:

^(?:(?:[^?+*{}()[\]\\|]+|\\.|\[(?:\^?\\.|\^[^\\]|[^\\^])(?:[^\]\\]+|\\.)*\]|\((?:\?[:=!]|\?<[=!]|\?>|\?<[^\W\d]\w*>|\?'[^\W\d]\w*')?(?<N>)|\)(?<-N>))(?:(?:[?+*]|\{\d+(?:,\d*)?\})[?+]?)?|\|)*$(?(N)(?!)) 

Answer 2

Improbable.

Evalúelo en un try..catch o cualquiera que sea su idioma.

Answer 3

Buena pregunta. Los verdaderos lenguajes regulares no pueden decidir paréntesis bien formados anidados de manera arbitraria. Es decir, si su alfabeto contiene '(' y ')', el objetivo es decidir si una cadena de estos tiene paréntesis coincidentes bien formados. Como este es un requisito necesario para las expresiones regulares, la respuesta es no.

Sin embargo, si afloja el requisito y agrega recursión, probablemente pueda hacerlo. La razón es que la recursión puede actuar como una 'pila' que le permite 'contar' la profundidad de anidación actual presionando sobre esta pila.

Russ Cox ha escrito un tratado de maravilla en expresiones regulares implementación del motor: Regular Expression Matching Can Be Simple And Fast

Answer 4

No se si está estrictamente hablando acerca de las expresiones regulares y no incluyendo algunas implementaciones de expresiones regulares que son realmente gramática libre de contexto.

Hay una limitación de las expresiones regulares que hace que sea imposible escribir una expresión regular que coincida con todas y solo las expresiones regulares. No puede hacer coincidir implementaciones tales como llaves que están emparejadas. Regexes usa muchos de estos constructos, permite tomar [] como ejemplo. Siempre que haya un [debe haber una coincidencia]. Lo suficientemente simple para una expresión regular "[. *]".

Lo que hace imposible que las expresiones regulares sean anidadas. ¿Cómo se puede escribir una expresión regular que coincida con los paréntesis anidados? La respuesta es que no se puede sin una expresión regular infinitamente larga. Puede hacer coincidir cualquier número de parens anidados a través de la fuerza bruta, pero nunca puede coincidir con un conjunto arbitrariamente largo de paréntesis anidados.

Esta capacidad a menudo se conoce como conteo (se está contando la profundidad de la anidación). Una expresión regular por definición no tiene la capacidad de contar.

EDIT: terminó escribiendo un blog acerca de esto: Regular Expression Limitations

Answer 5

Aunque es perfectamente posible utilizar una expresión regular recursiva como MizardX ha publicado, para este tipo de cosas es mucho más útil un programa de análisis. Regexes originalmente fue pensado para ser usado con los lenguajes regulares, recursivo o tener grupos de equilibrio es solo un parche.

El lenguaje que define expresiones regulares válidas es en realidad una gramática libre de contexto, y debe usar un analizador apropiado para manejarlo. Aquí hay un ejemplo de un proyecto universitario para analizar expresiones regulares simples (sin la mayoría de los constructos). Utiliza JavaCC. Y sí, los comentarios están en español, aunque los nombres de los métodos son bastante fáciles de entender.

SKIP : 
{ 
    " " 
| "\r" 
| "\t" 
| "\n" 
} 
TOKEN : 
{ 
    < DIGITO: ["0" - "9"] > 
| < MAYUSCULA: ["A" - "Z"] > 
| < MINUSCULA: ["a" - "z"] > 
| < LAMBDA: "LAMBDA" > 
| < VACIO: "VACIO" > 
} 

IRegularExpression Expression() : 
{ 
    IRegularExpression r; 
} 
{ 
    r=Alternation() { return r; } 
} 

// Matchea disyunciones: ER | ER 
IRegularExpression Alternation() : 
{ 
    IRegularExpression r1 = null, r2 = null; 
} 
{ 
    r1=Concatenation() ("|" r2=Alternation())? 
    { 
     if (r2 == null) { 
      return r1; 
     } else { 
      return createAlternation(r1,r2); 
     } 
    } 
} 

// Matchea concatenaciones: ER.ER 
IRegularExpression Concatenation() : 
{ 
    IRegularExpression r1 = null, r2 = null; 
} 
{ 
    r1=Repetition() ("." r2=Repetition() { r1 = createConcatenation(r1,r2); })* 
    { return r1; } 
} 

// Matchea repeticiones: ER* 
IRegularExpression Repetition() : 
{ 
    IRegularExpression r; 
} 
{ 
    r=Atom() ("*" { r = createRepetition(r); })* 
    { return r; } 
} 

// Matchea regex atomicas: (ER), Terminal, Vacio, Lambda 
IRegularExpression Atom() : 
{ 
    String t; 
    IRegularExpression r; 
} 
{ 
    ("(" r=Expression() ")" {return r;}) 
    | t=Terminal() { return createTerminal(t); } 
    | <LAMBDA> { return createLambda(); } 
    | <VACIO> { return createEmpty(); } 
} 

// Matchea un terminal (digito o minuscula) y devuelve su valor 
String Terminal() : 
{ 
    Token t; 
} 
{ 
    (t=<DIGITO> | t=<MINUSCULA>) { return t.image; } 
} 

Answer 6

Este example en el wiki pyparsing da una gramática para analizar algunas expresiones regulares, a los efectos de devolver el conjunto de cadenas que coinciden. Como tal, rechaza aquellas referencias que incluyen términos de repetición ilimitada, como '+' y '*'. Pero debería darle una idea sobre cómo estructurar un analizador que pueda procesar re.

Answer 7

Puede enviar la expresión regular a preg_match, que devolverá falso si la expresión regular no es válida. No se olvide de utilizar la '@' para suprimir mensajes de error:

@preg_match($regexToTest, ''); 

• volverá 1 si la expresión regular es '//'.
• devolverá 0 si la expresión regular está bien.
• devolverá falso de lo contrario.

Answer 8

Prueba con esto ...

//regular expression for email 
    var pattern = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/; 
    if(pattern.test(email)){ 
     return true; 
    } else { 
     return false; 
    }