regex - probar - expresiones regulares online
Expresión regular que no contiene cierta cadena (7)
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 ocurrencias de ".js" y si están precedidas por la cadena "EXCEPTION", descartar ese resultado 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.
Esta pregunta ya tiene una respuesta aquí:
Tengo algo como esto
aabbabcaabda
para seleccionar el grupo mínimo envuelto por un tengo /a([^a]*)a/ que funciona bien
Pero tengo problemas con los 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 que no contiene cadenas de la misma manera que puedo decir que no contiene caracteres con [^a] ?
Dicho simplemente, necesito aa seguido de cualquier caracter excepto la secuencia aa y luego termina con aa
En general, es un dolor escribir una expresión regular que no contenga 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 hay un tutorial muy breve. Encontré algunos excelentes antes, pero ya no los puedo ver.
No estoy seguro de que sea una construcción estándar, pero creo que debería echarle un vistazo a "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 comience por dígitos seguida de letras, A MENOS QUE "estos dígitos" sean 123.
http://msdn.microsoft.com/en-us/library/az24scfc%28v=vs.110%29.aspx#grouping_constructs (página de Microsoft, pero bastante completa) 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.
Por el poder de Google, encontré un blogpost de 2007 que proporciona la siguiente expresión regular que coincide con una cadena que no contiene una determinada subcadena:
^((?!my string).)*$
Funciona de la siguiente manera: busca cero o más (*) caracteres (.) Que no comiencen (?! - lookahead negativo) su cadena y estipula que toda la cadena debe estar compuesta de tales caracteres (usando el ^ y $ anclajes). O para decirlo de otra manera:
Toda la cadena debe estar compuesta de caracteres que no comiencen una cadena dada, lo que significa que la cadena no contiene la subcadena dada.
Todo lo que necesitas es un cuantificador reacio:
regex: /aa.*?aa/
aabbabcaabda => aabbabcaa
aaaaaabda => aaaa
aabbabcaabda => aabbabcaa
aababaaaabdaa => aababaa, aabdaa
También puedes usar el look-up negativo, pero en este caso es una manera más detallada de 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 tenga solo dos caracteres, pero (como reconoció Claudiu) es demasiado difícil de manejar para cadenas más largas.
".*[^(//.inc)]//.ftl$"
En Java, encontrará todos los archivos que terminen en ".ftl" pero que no terminen en ".inc.ftl", que es exactamente lo que yo quería.
/aa([^a]|a[^a])*aa/