Uso de RegEx para equilibrar el paréntesis de coincidencia

Question

Estoy tratando de crear una expresión RegEx de .NET que equilibre correctamente mi paréntesis. Tengo la siguiente expresión RegEx:

func([a-zA-Z_][a-zA-Z0-9_]*)\(.*\) 

La cadena que estoy tratando de igualar es la siguiente:

"test -> funcPow((3),2) * (9+1)" 

Lo que debería suceder es expresión regular debe coincidir con todo, desde funcPow hasta el segundo paréntesis de cierre. Debería detenerse después del segundo paréntesis de cierre. En cambio, está haciendo coincidir todo el camino hasta el último paréntesis de cierre. RegEx está volviendo esto:

"funcPow((3),2) * (9+1)" 

debe devolver esto:

"funcPow((3),2)" 

Cualquier ayuda en esto sería apreciada.

Answer 1

expresiones regulares puede hacer definitivamente paréntesis equilibrado que empareja. Puede ser complicado y requiere un par de funciones Regex más avanzadas, pero no es demasiado difícil.

Ejemplo:

var r = new Regex(@" 
    func([a-zA-Z_][a-zA-Z0-9_]*) # The func name 

    \(      # First '(' 
     (?:     
     [^()]    # Match all non-braces 
     | 
     (?<open> \()  # Match '(', and capture into 'open' 
     | 
     (?<-open> \))  # Match ')', and delete the 'open' capture 
     )+ 
     (?(open)(?!))  # Fails if 'open' stack isn't empty! 

    \)      # Last ')' 
", RegexOptions.IgnorePatternWhitespace); 

se encontraron grupos equilibrados tiene un par de características, pero para este ejemplo, que sólo está utilizando la captura función de borrar. La línea (?<-open> \)) coincidirá con ) y eliminará la captura anterior "abierta".

La línea más complicada es (?(open)(?!)), así que déjame explicarte. (?(open) es una expresión condicional que solo coincide si hay una captura "abierta". (?!) es una expresión negativa que siempre falla. Por lo tanto, (?(open)(?!)) dice "si hay una captura abierta, entonces falla".

Microsoft's documentation fue muy útil también.

Answer 2

Las expresiones regulares solo funcionan en Regular Languages. Esto significa que una expresión regular puede encontrar cosas por el estilo "cualquier combinación de A y B". (ab o babbabaaa etc) pero que no puede encontrar "n una de, una b, n A". (a^n b a^n) Las expresiones regulares no pueden garantizar que el primer conjunto de a coincida con el segundo conjunto de a.

Debido a esto, no pueden coincidir con el mismo número de paréntesis de apertura y cierre. Sería bastante fácil escribir una función que atraviese la cadena un carácter a la vez. Tener dos contadores, uno para abrir paren, uno para cerrar. incremente los punteros a medida que recorre la cadena, si opening_paren_count != closing_parent_count devuelve falso.

Answer 3

func[a-zA-Z0-9_]*\((([^()])|(\([^()]*\)))*\) 

Puede usar eso, pero si está trabajando con .NET, puede haber mejores alternativas.

Esta parte ya saben:

func[a-zA-Z0-9_]*\(--weird part-- \) 

La parte parcialmente: --weird sólo significa; ( permite que cualquier carácter ., o | cualquier sección (.*) exista tantas veces como quiera )*. El único problema es que no puede hacer coincidir ningún carácter ., debe usar [^()] para excluir el paréntesis.

(([^()])|(\([^()]*\)))* 

Answer 4

El uso de grupos equilibrados, es:

Regex rx = new Regex(@"func([a-zA-Z_][a-zA-Z0-9_]*)\(((?<BR>\()|(?<-BR>\))|[^()]*)+\)"); 

var match = rx.Match("funcPow((3),2) * (9+1)"); 

var str = match.Value; // funcPow((3),2) 

(?<BR>\()|(?<-BR>\)) son un Balancing Group (la BR I utiliza para el nombre es para Brackets). Es más claro de esta manera (?<BR> \ ()|(?<-BR> \) ) tal vez, de modo que el \( y \) son más "evidente".

Si realmente odias a ti mismo (y el mundo/sus compañeros de programadores) lo suficiente como para usar estas cosas, se sugiere emplear la "pizca" espacio en blanco RegexOptions.IgnorePatternWhitespace y en todas partes :-)