Expresión regular que no contiene cierta cadena

Question

tengo algo como esto

aabbabcaabda

para la selección de grupo mínimo envuelto por una tengo este /a([^a]*)a/ que funciona muy bien

Pero tengo problemas con grupos envueltos por aa, donde necesitaría algo como /aa([^aa]*)aa/ que no funciona, y no puedo usar el primero como /aa([^a]*)aa/, porque terminaría en la primera aparición de a, que no quiero.

En general, ¿hay alguna manera, cómo decir no contiene cadena de la misma manera que puedo decir no contiene caracteres con [^a]?

Simplemente dicho, necesito aa seguido de cualquier carácter excepto secuencia aa y luego termina con aa

Answer 1

En general es un dolor en escribir una expresión regular no que contiene una cadena en particular. Tuvimos que hacer esto para los modelos de computación: tomas un NFA, que es bastante fácil de definir, y luego lo reduces a una expresión regular. La expresión para las cosas que no contienen "cat" tenía unos 80 caracteres.

Editar: acabo de terminar y sí, es:

aa([^a] | a[^a])aa 

Here es un breve tutorial. Encontré algunos excelentes antes, pero ya no los puedo ver.

Answer 2

/aa([^a]|a[^a])*aa/ 

Answer 3

Todo lo que necesita es un cuantificador renuente:

regex: /aa.*?aa/ 

aabbabcaabda => aabbabcaa 

aaaaaabda  => aaaa 

aabbabcaabda => aabbabcaa 

aababaaaabdaa => aababaa, aabdaa 

Usted podría utilizar búsqueda negativa hacia delante, también, pero en este caso es sólo una manera más prolija lograr lo mismo. Además, es un poco más complicado de lo que gpojd llegó a ser. La búsqueda anticipada debe aplicarse en cada posición antes de que el punto pueda consumir el siguiente carácter.

/aa(?:(?!aa).)*aa/ 

En cuanto al enfoque sugerido por Claudiu y finnw, funcionará bien cuando la cadena centinela es sólo dos caracteres de longitud, pero (como reconoció Claudiu) que sea demasiado difícil de manejar para cadenas más largas.

Answer 4

Por el poder de Google encontré a blogpost from 2007 que da la siguiente expresión regular que coincide con cadena que no lo hacen contiene una determinada subcadena:

^((?!my string).)*$ 

Funciona de la siguiente manera: se busca cero o más (*) caracteres (.) que no comienzan (?!- lookahead negativo) su cadena y estipula que toda la cadena debe estar compuesta por dichos caracteres (utilizando los anclajes^y $). O para decirlo de otra manera:

La cadena completa debe estar formada por caracteres que no comiencen una cadena dada, lo que significa que la cadena no contiene la subcadena dada.

Answer 5

".*[^(\\.inc)]\\.ftl$" 

En Java esto encontrará todos los archivos que terminan en ".ftl" pero que no terminan en ".inc.ftl", que es exactamente lo que yo quería.

Answer 6

I el siguiente código que tuve que reemplazar agrega un parámetro GET a todas las referencias a los archivos JS, EXCEPTO uno.

<link rel="stylesheet" type="text/css" href="/login/css/ABC.css" /> 
<script type="text/javascript" language="javascript" src="/localization/DEF.js"></script> 
<script type="text/javascript" language="javascript" src="/login/jslib/GHI.js"></script> 
<script type="text/javascript" language="javascript" src="/login/jslib/md5.js"></script> 
sendRequest('/application/srvc/EXCEPTION.js', handleChallengeResponse, null); 
sendRequest('/application/srvc/EXCEPTION.js",handleChallengeResponse, null); 

Este es el Matcher utilizado:

(?<!EXCEPTION)(\.js) 

Lo que hace es buscar todas las apariciones de ".js" y si están precedidos por la cadena 'excepción', descarte derivadas de la matriz de resultados Eso se llama mirada negativa detrás. Desde que pasé un día investigando cómo hacerlo, pensé que debería compartirlo.

Answer 7

No estoy seguro de que sea una construcción estándar, pero creo que debería echarle un vistazo al "lookahead negativo" (que escribe: "?!", Sin las comillas). Es mucho más fácil que todas las respuestas en este hilo, incluida la aceptada.

Ejemplo: Regex: "^ (?! 123) [0-9] * \ w" captura cualquier cadena que comienza por dígitos seguidos de letras, a menos que si "estos dígitos" son 123.

http://msdn.microsoft.com/en-us/library/az24scfc%28v=vs.110%29.aspx#grouping_constructs (página de Microsoft, pero bastante completo) para lookahead/lookbehind

PD: funciona bien para mí (.Net). Pero si me equivoco con algo, háganoslo saber. Encuentro esta construcción muy simple y efectiva, por lo que estoy sorprendido de la respuesta aceptada.