Una expresión regular que nunca será igualada por nada

Esto puede sonar como una pregunta estúpida, pero tuve una larga conversación con algunos de mis colegas desarrolladores y sonó como algo divertido de pensar.

Entonces; ¿Cuál es su pensamiento? ¿Cómo se ve un Regex, que nunca será igualado por ninguna cadena, nunca!

Editar : ¿Por qué quiero esto? Bueno, en primer lugar porque me parece interesante pensar en esa expresión y en segundo lugar porque lo necesito para un guión.

En ese script defino un diccionario como Dictionary<string, Regex>. Esto contiene, como puede ver, una cadena y una expresión.

Basado en ese diccionario, creo métodos que todos usan este diccionario como referencia solamente sobre cómo deben hacer su trabajo, uno de ellos compara las expresiones regulares contra un archivo de registro analizado.

Si una expresión coincide, a otra Dictionary<string, long>se le agrega un valor que devuelve la expresión. Entonces, para capturar cualquier mensaje de registro que no coincida con una expresión en el diccionario, creé un nuevo grupo llamado "desconocido".

A este grupo se agrega todo lo que no coincide con nada más. Pero para evitar que la expresión "desconocida" no coincida (por accidente) con un mensaje de registro, tuve que crear una expresión que ciertamente nunca coincide, sin importar la cadena que le dé.

Por lo tanto, ahí tienes mi razón para esta "no es una pregunta real" ...

En realidad, esto es bastante simple, aunque depende de la implementación / flags *:

$a

Coincidirá con un personaje adespués del final de la cadena. Buena suerte.

ADVERTENCIA:
Esta expresión es costosa: escaneará toda la línea, buscará el ancla de fin de línea y solo entonces no encontrará la ay devolverá una coincidencia negativa. (Vea el comentario a continuación para obtener más detalles).

^* Originalmente no pensé mucho en expresiones regulares en modo multilínea, donde $también coincide con el final de una línea. De hecho, coincidiría con la cadena vacía justo antes de la nueva línea , por lo que un carácter ordinario como anunca puede aparecer después $.

Apalancamiento negative lookahead:

>>> import re
>>> x=r'(?!x)x'
>>> r=re.compile(x)
>>> r.match('')
>>> r.match('x')
>>> r.match('y')

este RE es una contradicción en los términos y, por lo tanto, nunca coincidirá con nada.

NOTA:
En Python, re.match () agrega implícitamente un ancla de inicio de cadena ( \A) al comienzo de la expresión regular. Este ancla es importante para el rendimiento: sin él, se escaneará toda la cadena. Aquellos que no usan Python querrán agregar el ancla explícitamente:

\A(?!x)x

Uno que se perdió:

^\b$

No puede coincidir porque la cadena vacía no contiene un límite de palabra. Probado en Python 2.5.

mira alrededor:

(?=a)b

Para los novatos de expresiones regulares: la mirada positiva hacia adelante (?=a)asegura que el siguiente carácter sea a, pero no cambia la ubicación de búsqueda (ni incluye la 'a' en la cadena coincidente). Ahora que se confirma que el siguiente carácter es a, la parte restante de la expresión regular ( b) coincide solo si el siguiente carácter lo es b. Por lo tanto, esta expresión regular coincide solo si un personaje es ambos ay bal mismo tiempo.

a\bc, donde \bes una expresión de ancho cero que coincide con el límite de la palabra.

No puede aparecer en el medio de una palabra, a lo que lo forzamos.

$.

.^

$.^

(?!)

Máxima correspondencia

a++a

Al menos uno aseguido de cualquier número de a's, sin retroceder. Luego trata de hacer coincidir uno más a.

o Subexpresión independiente

Esto es equivalente a poner a+una subexpresión independiente, seguida de otra a.

(?>a+)a

Perl 5.10 admite palabras de control especiales llamadas "verbos", que están encerrados en (*...)secuencia. (Compárese con (?...)una secuencia especial). Entre ellos, incluye el (*FAIL)verbo que regresa de la expresión regular inmediatamente.

Tenga en cuenta que los verbos también se implementan en PCRE poco después, por lo que puede usarlos en PHP u otros lenguajes usando la biblioteca PCRE también. (Sin embargo, no puedes en Python o Ruby. Usan su propio motor).

\B\b

\bcoincide con los límites de las palabras: la posición entre una letra y una no letra (o el límite de la cadena).
\Bes su complemento: coincide con la posición entre dos letras o entre no letras.

Juntos no pueden igualar ninguna posición.

Ver también:

• Límites de palabras
• Este patrón no coincide con algunas posiciones.
• Inspiración

Esto parece funcionar:

$.

¿Qué $^tal o tal vez (?!)? 

El más rápido será:

r = re.compile(r'a^')
r.match('whatever')

'a' puede ser cualquier carácter no especial ('x', 'y'). La implementación de Knio podría ser un poco más pura, pero esta será más rápida para todas las cadenas que no comiencen con el carácter que elija en lugar de 'a' porque no coincidirá después del primer carácter en lugar de después del segundo en esos casos.

Python no lo aceptará, pero Perl:

perl -ne 'print if /(w\1w)/'

Esta expresión regular debería (en teoría) tratar de hacer coincidir un número infinito (par) de ws, porque el primer grupo ( ()s) se repite en sí mismo. Perl no parece emitir ninguna advertencia, incluso debajo use strict; use warnings;, por lo que supongo que es al menos válido, y mis pruebas (mínimas) no coinciden con nada, así que lo envío para su crítica.

[^\d\D]o (?=a)bo a$aoa^a

Esto no funcionará para Python y muchos otros lenguajes, pero en una expresión regular de Javascript, []es una clase de caracteres válida que no se puede comparar. Entonces, lo siguiente debería fallar inmediatamente, sin importar la entrada:

var noMatch = /^[]/;

Me gusta más que /$a/porque, para mí, comunica claramente su intención. Y en cuanto a cuándo lo necesitaría, lo necesitaba porque necesitaba un respaldo para un patrón compilado dinámicamente basado en la entrada del usuario. Cuando el patrón no es válido, necesito reemplazarlo con un patrón que no coincida con nada. Simplificado, se ve así:

try {
    var matchPattern = new RegExp(someUserInput);
}
catch (e) {
    matchPattern = noMatch;
}

Todos los ejemplos que involucran una coincidencia de límites siguen la misma receta. Receta:

1. Tome cualquiera de los comparadores de límites: ^, $, \ b, \ A, \ Z, \ z

2. Hacer lo contrario a lo que están destinados

Ejemplos:

^ y \ A están destinados al principio, así que no los use al principio

^ --> .^
\A --> .\A

\ b coincide con un límite de palabra, así que úselo entre

\b --> .\b.

$, \ Z y \ z están destinados al final, así que no los uses al final

$ --> $.
\Z --> \Z.
\z --> \z.

Otros implican el uso de lookahead y lookbehind, que también funcionan con la misma analogía: si da un lookahead positivo o negativo seguido de algo opuesto

(?=x)[^x]
(?!x)x

Si das una mirada positiva o negativa detrás de algo opuesto

[^x](?<=x)
x(?<!x)

Podrían existir más patrones y más analogías.

¡Tantas buenas respuestas!

Similar a la respuesta de @ nivk, me gustaría compartir la comparación de rendimiento de Perl para diferentes variantes de expresiones regulares que nunca coinciden.

1. Entrada: cadenas ascii pseudoaleatorias (25,000 líneas diferentes, longitud 8-16):

Velocidad de expresión regular:

Total for   \A(?!x)x: 69.675450 s, 1435225 lines/s
Total for       a\bc: 71.164469 s, 1405195 lines/s
Total for    (?>a+)a: 71.218324 s, 1404133 lines/s
Total for       a++a: 71.331362 s, 1401907 lines/s
Total for         $a: 72.567302 s, 1378031 lines/s
Total for     (?=a)b: 72.842308 s, 1372828 lines/s
Total for     (?!x)x: 72.948911 s, 1370822 lines/s
Total for       ^\b$: 79.417197 s, 1259173 lines/s
Total for         $.: 88.727839 s, 1127041 lines/s
Total for       (?!): 111.272815 s, 898692 lines/s
Total for         .^: 115.298849 s, 867311 lines/s
Total for    (*FAIL): 350.409864 s, 285380 lines/s

2. Entrada: / usr / share / dict / words (100,000 palabras en inglés).

Velocidad de expresión regular:

Total for   \A(?!x)x: 128.336729 s, 1564805 lines/s
Total for     (?!x)x: 132.138544 s, 1519783 lines/s
Total for       a++a: 133.144501 s, 1508301 lines/s
Total for    (?>a+)a: 133.394062 s, 1505479 lines/s
Total for       a\bc: 134.643127 s, 1491513 lines/s
Total for     (?=a)b: 137.877110 s, 1456528 lines/s
Total for         $a: 152.215523 s, 1319326 lines/s
Total for       ^\b$: 153.727954 s, 1306346 lines/s
Total for         $.: 170.780654 s, 1175906 lines/s
Total for       (?!): 209.800379 s, 957205 lines/s
Total for         .^: 217.943800 s, 921439 lines/s
Total for    (*FAIL): 661.598302 s, 303540 lines/s

(Ubuntu en Intel i5-3320M, Linux kernel 4.13, Perl 5.26)

Yo creo eso

\Z RE FAILS! \A

cubre incluso los casos en los que la expresión regular incluye marcas como MULTILINE, DOTALL, etc.

>>> import re
>>> x=re.compile(r"\Z RE FAILS! \A")
>>> x.match('')
>>> x.match(' RE FAILS! ')
>>>

Creo (pero no lo he comparado) que cualquiera que sea la longitud (> 0) de la cadena entre \Zy \A, el tiempo de falla debe ser constante.

(*FAIL)

o

(*F)

Con PCRE y PERL puede usar este verbo de control de retroceso que obliga al patrón a fallar inmediatamente.

Después de ver algunas de estas excelentes respuestas, el comentario de @arantius (con respecto al tiempo $xvs x^vs (?!x)x) sobre la respuesta actualmente aceptada me hizo querer cronometrar algunas de las soluciones dadas hasta ahora.

Usando el estándar de línea de 275k de @ arantius, ejecuté las siguientes pruebas en Python (v3.5.2, IPython 6.2.1).

TL; DR: 'x^'y 'x\by'son los más rápidos por un factor de al menos ~ 16, y contrario al hallazgo de @ arantius, (?!x)xfue uno de los más lentos (~ 37 veces más lento). Entonces, la cuestión de la velocidad ciertamente depende de la implementación. Pruébelo usted mismo en su sistema previsto antes de confirmar si la velocidad es importante para usted.

ACTUALIZACIÓN: Al parecer, existe una gran discrepancia entre el tiempo 'x^'y 'a^'. Consulte esta pregunta para obtener más información y la edición anterior para los tiempos más lentos con en alugar de x.

In [1]: import re

In [2]: with open('/tmp/longfile.txt') as f:
   ...:     longfile = f.read()
   ...:     

In [3]: len(re.findall('\n',longfile))
Out[3]: 275000

In [4]: len(longfile)
Out[4]: 24733175

In [5]: for regex in ('x^','.^','$x','$.','$x^','$.^','$^','(?!x)x','(?!)','(?=x)y','(?=x)(?!x)',r'x\by',r'x\bx',r'^\b$'
    ...: ,r'\B\b',r'\ZNEVERMATCH\A',r'\Z\A'):
    ...:     print('-'*72)
    ...:     print(regex)
    ...:     %timeit re.search(regex,longfile)
    ...:     
------------------------------------------------------------------------
x^
6.98 ms ± 58.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
------------------------------------------------------------------------
.^
155 ms ± 960 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$x
111 ms ± 2.12 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$.
111 ms ± 1.76 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$x^
112 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$.^
113 ms ± 1.44 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
$^
111 ms ± 839 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
(?!x)x
257 ms ± 5.03 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
------------------------------------------------------------------------
(?!)
203 ms ± 1.56 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
(?=x)y
204 ms ± 4.84 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
------------------------------------------------------------------------
(?=x)(?!x)
210 ms ± 1.66 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
------------------------------------------------------------------------
x\by
7.41 ms ± 122 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
------------------------------------------------------------------------
x\bx
7.42 ms ± 110 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
------------------------------------------------------------------------
^\b$
108 ms ± 1.05 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
\B\b
387 ms ± 5.77 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
------------------------------------------------------------------------
\ZNEVERMATCH\A
112 ms ± 1.52 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
------------------------------------------------------------------------
\Z\A
112 ms ± 1.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

La primera vez que ejecuté esto, olvidé rmostrar las últimas 3 expresiones, por lo que '\b'se interpretó como '\x08'el carácter de retroceso. Sin embargo, para mi sorpresa, ¡ 'a\x08c'fue más rápido que el resultado más rápido anterior! Para ser justos, aún coincidirá con ese texto, pero pensé que todavía valía la pena señalarlo porque no estoy seguro de por qué es más rápido.

In [6]: for regex in ('x\by','x\bx','^\b$','\B\b'):
    ...:     print('-'*72)
    ...:     print(regex, repr(regex))
    ...:     %timeit re.search(regex,longfile)
    ...:     print(re.search(regex,longfile))
    ...:     
------------------------------------------------------------------------
y 'x\x08y'
5.32 ms ± 46.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
None
------------------------------------------------------------------------
x 'x\x08x'
5.34 ms ± 66.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
None
------------------------------------------------------------------------
$ '^\x08$'
122 ms ± 1.05 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
None
------------------------------------------------------------------------
\ '\\B\x08'
300 ms ± 4.11 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
None

Mi archivo de prueba fue creado usando una fórmula para "... Contenido legible y sin líneas duplicadas" (en Ubuntu 16.04):

$ ruby -e 'a=STDIN.readlines;275000.times do;b=[];rand(20).times do; b << a[rand(a.size)].chomp end; puts b.join(" "); end' < /usr/share/dict/words > /tmp/longfile.txt

$ head -n5 /tmp/longfile.txt 
unavailable speedometer's garbling Zambia subcontracted fullbacks Belmont mantra's
pizzicatos carotids bitch Hernandez renovate leopard Knuth coarsen
Ramada flu occupies drippings peaces siroccos Bartók upside twiggier configurable perpetuates tapering pint paralyzed
vibraphone stoppered weirdest dispute clergy's getup perusal fork
nighties resurgence chafe

Expresiones regulares vacías

La mejor expresión regular para que nunca coincida con nada es una expresión regular vacía. Pero no estoy seguro de que todo el motor de expresiones regulares lo acepte.

Regex imposible

La otra solución es crear una expresión regular imposible. Descubrí que $-^solo toma dos pasos para calcular, independientemente del tamaño de su texto ( https://regex101.com/r/yjcs1Z/1 ).

Para referencia:

• $^y $.tome 36 pasos para calcular -> O (1)
• \b\B toma 1507 pasos en mi muestra y aumenta con el número de caracteres en su cadena -> O (n)

Tema más popular sobre esta pregunta:

• Regex para * no * coincide con cualquier carácter

¿Tal vez esto?

/$.+^/

'[^0-9a-zA-Z...]*'

y reemplace ... con todos los símbolos imprimibles;). Eso es para un archivo de texto.

¿Qué pasa en lugar de expresiones regulares, solo use una declaración if falsa? En javascript:

var willAlwaysFalse=false;
if(willAlwaysFalse)
{
}
else
{
}

Una solución portátil que no dependerá de la implementación de regexp es usar una cadena constante que está seguro de que nunca aparecerá en los mensajes de registro. Por ejemplo, haga una cadena basada en lo siguiente:

cat /dev/urandom | hexdump | head -20
0000000 5d5d 3607 40d8 d7ab ce72 aae1 4eb3 ae47
0000010 c5e2 b9e8 910d a2d9 2eb3 fdff 6301 c85f
0000020 35d4 c282 e439 33d8 1c73 ca78 1e4d a569
0000030 8aca eb3c cbe4 aff7 d079 ca38 8831 15a5
0000040 818b 323f 0b02 caec f17f 387b 3995 88da
0000050 7b02 c80b 2d42 8087 9758 f56f b71f 0053
0000060 1501 35c9 0965 2c6e 03fe 7c6d f0ca e547
0000070 aba0 d5b6 c1d9 9bb2 fcd1 5ec7 ee9d 9963
0000080 6f0a 2c91 39c2 3587 c060 faa7 4ea4 1efd
0000090 6738 1a4c 3037 ed28 f62f 20fa 3d57 3cc0
00000a0 34f0 4bc2 3067 a1f7 9a87 086b 2876 1072
00000b0 d9e1 6b8f 5432 a60e f0f5 00b5 d9ef ed6f
00000c0 4a85 70ee 5ec4 a378 7786 927f f126 2ec2
00000d0 18c5 46fe b167 1ae6 c87c 1497 48c9 3c09
00000e0 8d09 e945 13ce 7da2 08af 1a96 c24c c022
00000f0 b051 98b3 2bf5 4d7d 5ec4 e016 a50d 355b
0000100 0e89 d9dd b153 9f0e 9a42 a51f 2d46 2435
0000110 ef35 17c2 d2aa 3cc7 e2c3 e711 d229 f108
0000120 324e 5d6a 650a d151 bc55 963f 41d3 66ee
0000130 1d8c 1fb1 1137 29b2 abf7 3af7 51fe 3cf4

Claro, este no es un desafío intelectual, sino más bien una programación de cinta adhesiva .

new Regex(Guid.NewGuid().ToString())

Crea un patrón que solo contiene caracteres alfanuméricos y ' -' (ninguno de los cuales son caracteres especiales de expresiones regulares), pero es estadísticamente imposible que la misma cadena haya aparecido en algún lugar antes (porque ese es el objetivo de un GUID).