Expresión regular para identificar declaraciones if

Question

Estoy tratando de escribir una expresión regular para identificar una instrucción if. El único problema que tengo es obtenerlo si las declaraciones tienen paréntesis entre paréntesis. Por ejemplo:

if (condition_function(params)) { 
    statements; 
} 

Mi expresión para capturar todos los estados excepto si éstos es:

if\s*\(([^\(\)]|\s)*\)\s*{(.|\s)*?} 

¿Alguien sabe cómo se escribe eso?

Answer 1

Creo que esto puede funcionar. Si alguien ve algo que yo no veo, como una razón por la que no funcionará, por favor responde.

if\s*\(((?:[^\(\)]|\((?1)\))*+)\)\s*{((?:[^{}]|{(?2)})*+)} 

El único problema que esto debería encontrar ahora es si hay una instrucción if en una instrucción if.

He probado esto en cada sentencia if válida que puedo pensar que podría romperla y lo único que no funciona es una que contiene una cadena con un paréntesis sin igual.

Actualización: Encontré un error con la expresión regular anterior. No detecta si las instrucciones que contienen cadenas con paréntesis no coincidentes en sus secciones de condición o enunciado. Como en el siguiente ejemplo:

if (var1 == "("){ 
    echo "{"; 
} 

Sin embargo, esta es una declaración if válida.La solución:

if\s*\(((?:(?:(?:"(?:(?:\\")|[^"])*")|(?:'(?:(?:\\')|[^'])*'))|[^\(\)]|\((?1)\))*+)\)\s*{((?:(?:(?:"(?:(?:\\")|[^"])*")|(?:'(?:(?:\\')|[^'])*'))|[^{}]|{(?2)})*+)}\s* 

Esta expresión regular captura todo si las declaraciones incluso los que contienen cadenas con paréntesis sin igual.

ACTUALIZACIÓN: Ahora lo tengo para que se capture el else y si las declaraciones que se adjuntan a las declaraciones if. El único problema es que los grupos de captura que devuelve son el último y el último si está en la instrucción if. Espero poder resolverlo también.

if\s*\(((?:(?:(?:"(?:(?:\\")|[^"])*")|(?:'(?:(?:\\')|[^'])*'))|[^\(\)]|\((?1)\))*+)\)\s*{((?:(?:(?:"(?:(?:\\")|[^"])*")|(?:'(?:(?:\\')|[^'])*'))|[^{}]|{(?2)})*+)}\s*(?:(?:else\s*{((?:(?:(?:"(?:(?:\\")|[^"])*")|(?:'(?:(?:\\')|[^'])*'))|[^{}]|{(?3)})*+)}\s*)|(?:else\s*if\s*\(((?:(?:(?:"(?:(?:\\")|[^"])*")|(?:'(?:(?:\\')|[^'])*'))|[^\(\)]|\((?4)\))*+)\)\s*{((?:(?:(?:"(?:(?:\\")|[^"])*")|(?:'(?:(?:\\')|[^'])*'))|[^{}]|{(?5)})*+)}\s*))*; 

Si desea probarlo, aquí hay un gran sitio web para ello: http://gskinner.com/RegExr/

Answer 2

Eso no es posible con expresiones regulares ya que las expresiones regulares solo pueden coincidir con los lenguajes regulares y la que está tratando de analizar no tiene contexto y no regular (gracias a dirkgently y dmckee).

Tenga una mirada en WP: Formal language theory es que está interesado ...

BTW. Ni siquiera puede verificar una expresión hecha solo entre paréntesis si es correcta ([[][]] es correcta, pero []][ no), que es un "subproblema" del que proporcionó anteriormente.

Answer 3

Si usted tiene que utilizar una expresión regular a pesar de que nunca se pondrá al día todos casos, éste es mejor:

if\s*\(((?!\s*\{).+)\)\s*\{(.|\s)*?\} 

Se utiliza un positive lookahead ((?!\s*\{).) que aseguran captar todo hasta el cierre ) (excepto si su estado de condición tiene un "{" en él! Aquí es donde la expresión regular no puede ayudarle)

Answer 4

¿Está tratando de escribir una expresión regular para analizar un idioma no habitual? Eso nunca volará.

Answer 5

un tiro rápido en ello ...

if\s*?\(.*?)\s*?(({?\s*?(.*?;)+\s*?})|(.*?;)) 

Answer 6

r = /\bif\s*\(/ 

txt = <<TXT 
if(test) 
if (test) 
if (xyz) 
; if 
print x if(true) 
TXT 

p txt.scan(r) 

si (algo) .. algo puede ser cualquier cosa .. si hay una cadena con un paréntesis de poner fin a su interior y que quieren tratar correctamente con los pares de paréntesis que coinciden, entonces terminará rápidamente con una gran expresión regular.

¿También con qué idioma está tratando de hacer frente?

Answer 7

tiene que escribir código en un lenguaje Turing completo. Existen herramientas que pueden construir automáticamente el código para usted, como Flex. Sin embargo, si tiene un problema simple, probablemente sea más fácil simplemente escribir un código de análisis simple. Aquí hay un ejemplo de código C# que podría ayudarlo a comenzar.

public void TestIf() 
    { 
     var s = @"if (condition_function(params)) { 
    statements; 
     }"; 
     var ifRegex = @"if *\(.*\) *{.*}"; 
     if (Regex.IsMatch(s, ifRegex, RegexOptions.Singleline)) 
     { 
     var firstParens = s.IndexOf('('); 
     if (firstParens != -1) 
     { 
      var conditionPart = s.Skip(firstParens + 1); 
      int stack = 1; 
      int lastParens = -1; 
      while(stack > 0) 
      { 
      for (int i = 0; i < conditionPart.Count(); i++) 
      { 
       var c = conditionPart.ElementAt(i); 
       if (c == '(') 
       { 
       stack++; 
       } 
       if (c == ')') 
       { 
       stack--; 
       } 
       if (stack == 0) 
       { 
       lastParens = i; 
       break; 
       } 
      } 
      } 
      if (lastParens != -1) 
      { 
      var condition = conditionPart.Take(lastParens); 
      Console.WriteLine(new string(condition.ToArray())); 
      } 
     } 
     } 
    } 

Answer 8

Modificado expresión regular (Koukaakiva), para encontrar sin paréntesis - https://regex101.com/r/fE6hA5/1 y ha añadido nombres de patrón