Regex: coincide con todo, pero

Necesito una expresión regular capaz de hacer coincidir todo, excepto una cadena que comienza con un patrón específico (específicamente index.php y lo que sigue, como index.php?id=2342343 )

No soy un experto en expresiones regulares, pero creo que podrías usar un lookahead negativo desde el principio, por ejemplo ^(?!foo).*$ No debería coincidir con nada que comience con foo .

Puede poner ^ en el comienzo de un conjunto de caracteres para que coincida con cualquier cosa que no sean esos caracteres.

 [^=]* 

coincidirá todo pero =

Regex: combina todo pero :

  • una cadena que comienza con un patrón específico (por ejemplo, cualquier – vacío, también – cadena que no comienza con foo ):
    • Solución basada en la búsqueda anticipada para NFA:
      • ^(?!foo).*$
      • ^(?!foo)
    • Solución basada en clase de carácter negada para motores regex que no admiten soluciones alternativas :
      • ^(([^f].{2}|.[^o].|.{2}[^o]).*|.{0,2})$
      • ^([^f].{2}|.[^o].|.{2}[^o])|^.{0,2}$
  • una cadena que termina con un patrón específico (digamos, no world. al final):
    • Solución basada en Lookbehind:
      • (?
      • ^.*(?
    • Solución POSIX:
      • ^(.*([^w].{5}|.[^o].{4}|.{2}[^r].{3}|.{3}[^l].{2}|.{4}[^d].|.{5}[^.])|.{0,5})$
      • ([^w].{5}|.[^o].{4}|.{2}[^r].{3}|.{3}[^l].{2}|.{4}[^d].|.{5}[^.]$|^.{0,5})$
  • una cadena que contiene un texto específico (por ejemplo, no coincide con una cadena que tiene foo ) (sin patern compatible con POSIX, lo siento):
    • ^(?!.*foo)
    • ^(?!.*foo).*$
  • una cadena que contiene un carácter específico (por ejemplo, evite hacer coincidir una cadena que tenga un | símbolo):
    • ^[^|]*$
  • una cadena igual a una cadena (digamos, no igual a foo ):
    • Basado en lookaround:
      • ^(?!foo$)
      • ^(?!foo$).*$
    • POSIX:
      • ^(.{0,2}|.{4,}|[^f]..|.[^o].|..[^o])$
  • una secuencia de caracteres :
    • PCRE (coincide con cualquier texto excepto cat ): /cat(*SKIP)(*FAIL)|[^c]*(?:c(?!at)[^c]*)*/i o /cat(*SKIP)(*FAIL)|(?:(?!cat).)+/is
    • Otros motores que permiten "lookarounds": (cat)|[^c]*(?:c(?!at)[^c]*)* At (cat)|[^c]*(?:c(?!at)[^c]*)* (o (?s)(cat)|(?:(?!cat).)* , o (cat)|[^c]+(?:c(?!at)[^c]*)*|(?:c(?!at)[^c]*)+[^c]* ) y luego verifique con el idioma significa: si el Grupo 1 coincide, no es lo que necesitamos; de lo contrario, tome el valor del partido si no está vacío
  • un cierto carácter individual o un conjunto de caracteres :
    • Utilice una clase de carácter negada : [^az]+ (cualquier carácter que no sea una letra ASCII en minúscula)
    • Coincidencia de cualquier char (s) pero | : [^|]+

Nota demo : la nueva línea \n se usa dentro de las clases de caracteres negadas en demostraciones para evitar el desbordamiento de coincidencia a la (s) línea (s) vecina (s). No son necesarios cuando se prueban cadenas individuales.

Nota de anclaje : en muchos idiomas, use \A para definir el inicio no ambiguo de la cadena, y \z (en Python, es \Z , en JavaScript, $ está OK) para definir el final de la cadena.

Nota de puntos : en muchos sabores (pero no en POSIX, TRE, TCL),. coincide con cualquier char, pero con un carácter nuevo. Asegúrese de utilizar un modificador DOTALL correspondiente ( /s en PCRE / Boost / .NET / Python / Java y /m en Ruby) para . para que coincida con cualquier char incluyendo una nueva línea.

Nota de retroceso : en los idiomas en los que debe declarar patrones con cadenas C que permiten secuencias de escape (como \n para una línea nueva), debe doblar las barras diagonales que escapan de caracteres especiales para que el motor los trate como caracteres literales (por ejemplo, en Java world\. se declarará como "world\\." , o usará una clase de caracteres: "world[.]" ). Utilice literales de cadena sin formato (Python r'\bworld\b' ), C # literal literales de cadena @"world\." , o notaciones literales slashy strings / regex como /world\./ .

En Python:

 >>> import re >>> p='^(?!index\.php\?[0-9]+).*$' >>> s1='index.php?12345' >>> re.match(p,s1) >>> s2='index.html?12345' >>> re.match(p,s2) <_sre.SRE_Match object at 0xb7d65fa8> 

Simplemente /^index\.php/ coincidir /^index\.php/ luego rechace lo que corresponda.

grep -v en shell

! ~ en perl

Agregue más en otros idiomas: marqué esto como Wiki de la comunidad.

¿Qué tal si no usas Regex?

 // In PHP 0 !== strpos($string, 'index.php')