RegEx para detectar si una línea no termina en un punto y coma

Question

Estoy tratando de ejecutar algunos archivos de código y buscar líneas que no terminan en un punto y coma.

Actualmente tengo esto: ^(?:(?!;).)*$ de un grupo de Google y funciona muy bien. Pero ahora quiero expandirlo, por lo que ignora todos los espacios en blanco al inicio o palabras clave específicas como paquete o llaves de apertura y cierre.

¡El fin es tomar algo como esto:

package example 
{ 
    public class Example 
    { 
     var i = 0 

     var j = 1; 

     // other functions and stuff 
    } 
} 

Y para el patrón para mostrar mi var i = 0 le falta un punto y coma. Es solo un ejemplo, el punto y coma faltante podría estar en cualquier parte de la clase.

¿Alguna idea? He estado jugando durante más de una hora, pero no tuve suerte.

Gracias.

Answer 1

Prueba esto:

^\s*(?!package|public|class|//|[{}]).*(?<!;\s*)$ 

Cuando se ensaya de PowerShell:

PS> (gc file.txt) -match '^\s*(?!package|public|class|//|[{}]).*(?<!;\s*)$' 
     var i = 0 
PS> 

Answer 2

Para la línea sólo que no terminan en un punto y coma, esto es más simple:

.*[^;]$ 

Si no desea que las líneas que comienzan con un espacio en blanco y terminando con punto y coma:

^[^ ].*[^;]$ 

Answer 3

Si Si desea una línea que no termine en un punto y coma, puede solicitar cualquier cantidad .* seguido de un carácter que no sea un punto y coma [^;] seguido, posiblemente, de algunos espacios en blanco \s* al final de la línea $. Por lo que tiene:

.*[^;]\s*$ 

Ahora bien, si no desea que los espacios en blanco al principio que hay que preguntarse para el comienzo de la línea ^ seguido de cualquier carácter que no sea un espacio en blanco [^\s] seguido de la expresión regular de antes:

^[^\s].*[^;]\s*$ 

Si no desea que se inicie con una palabra clave como package o, por ejemplo, class o espacios en blanco que se puede pedir a un personaje que no es ninguna de esas tres cosas. La expresión regular que coincide con cualquiera de estas tres cosas es (?:\s|package|class) y la expresión regular que coincide con cualquier cosa que no sea ellos es (?!\s|package|class). Tenga en cuenta el !. Por lo que ahora tiene:

^(?!\s|package|class).*[^;]\s*$ 

Answer 4

Usted está tratando de hacer coincidir las líneas que comienzan con un espacio en blanco posiblemente ^\s*, entonces no tienen un conjunto determinado de palabras, por ejemplo (?!package|class), entonces tiene nada .* pero luego no terminan en un punto y coma (o un punto y coma con espacios en blanco después) [^;]\s*.

^\s*(?!package|class).*?[^;]\s*$ 

Tenga en cuenta que he agregado paréntesis alrededor de una sección de la expresión regular.

Answer 5

La clave para captar este concepto complicado en una expresión regular es primero entender cómo su expresión motor/intérprete regularmente maneja los siguientes conceptos:

1. búsqueda positiva hacia delante
2. búsqueda negativa hacia delante
3. de búsqueda hacia atrás positiva
4. aspecto negativo detrás

Entonces puede comenzar a comprender d cómo capturar lo que desea, pero solo en los casos en que lo que está adelante y lo que está atrás es exactamente lo que usted especifica.

str.scan(/^\s*(?=\S)(?!package.+\n|public.+\n|\/\/|\{|\})(.+)(?<!;)\s*$/) 

Answer 6

Ésta es la línea de expresiones regulares que estoy usando para resaltar las líneas de código Java que no terminan en punto y coma y no son una de las líneas en java que no se supone que tengan un punto y coma al final ... usando el motor de expresión regular de vim.

\(.\+[^; ]$\)\(^.*public.*\|.*//.*\|.*interface.*\|.*for.*\|.*class.*\|.*try.*\|^\s*if\s\+.*\|.*private.*\|.*new.*\|.*else.*\|.*while.*\|.*protected.*$\)\@<! 
^  ^                                  ^
    |   |                             negative lookbehind feature 
    |   | 
    |   2. But not where such matches are preceeded by these keywords 
    | 
    | 
    1. Group of at least some anychar preceeding a missing semicolon 

mnemotécnicos para descifrar los glifos:

^   beginning of line 
.*   Any amount of any char 
+   at least one 
[^ ... ] everything but 
$   end of line 
\(... \) group 
\|   delimiter 
\@<!  negative lookbehind 

que se podría traducir:

Encuéntrame todas las líneas que no terminan en un punto y coma y que no tienen ninguna de las palabras clave anteriores/expresiones a la izquierda de ella. No es perfecto y probablemente no resista el java ofuscado, pero para programas Java simples destaca las líneas que deberían tener punto y coma al final, pero no lo hacen.

Imagen que muestra cómo esta expresión está funcionando para mí:

enlace útil que me ayudó a que los conceptos que necesitaba:

https://jbodah.github.io/blog/2016/11/01/positivenegative-lookaheadlookbehind-vim/