Ein Regex, mit dem nichts mithalten kann

Das mag nach einer dummen Frage klingen, aber ich hatte ein langes Gespräch mit einigen meiner Entwicklerkollegen und es klang nach einer lustigen Sache.

So; Was denkst du - wie sieht ein Regex aus, der niemals von einer Saite übertroffen wird?

Edit : Warum will ich das? Nun, erstens, weil ich es interessant finde, an einen solchen Ausdruck zu denken, und zweitens, weil ich ihn für ein Skript brauche.

In diesem Skript definiere ich ein Wörterbuch als Dictionary<string, Regex>. Dies enthält, wie Sie sehen, eine Zeichenfolge und einen Ausdruck.

Basierend auf diesem Wörterbuch erstelle ich Methoden, die alle dieses Wörterbuch nur als Referenz dafür verwenden, wie sie ihre Arbeit erledigen sollen. Eine davon vergleicht die regulären Ausdrücke mit einer analysierten Protokolldatei.

Wenn ein Ausdruck übereinstimmt, Dictionary<string, long>wird einem anderen ein Wert hinzugefügt, der vom Ausdruck zurückgegeben wird. Um alle Protokollnachrichten abzufangen, die nicht mit einem Ausdruck im Wörterbuch übereinstimmen, habe ich eine neue Gruppe mit dem Namen "unbekannt" erstellt.

Zu dieser Gruppe wird alles hinzugefügt, was mit nichts anderem übereinstimmt. Aber um zu verhindern, dass der "unbekannte" Ausdruck (aus Versehen) einer Protokollnachricht nicht entspricht, musste ich einen Ausdruck erstellen, der mit Sicherheit nie übereinstimmt, egal welche Zeichenfolge ich ihm gebe.

Da haben Sie also meinen Grund für diese "keine wirkliche Frage" ...

Dies ist eigentlich recht einfach, obwohl es von der Implementierung / Flags * abhängt :

$a

Entspricht einem Zeichen anach dem Ende der Zeichenfolge. Viel Glück.

WARNUNG:
Dieser Ausdruck ist teuer - er scannt die gesamte Zeile, findet den Zeilenende-Anker und findet erst dann den nicht aund gibt eine negative Übereinstimmung zurück. (Siehe Kommentar unten für weitere Einzelheiten.)

^* Ursprünglich habe ich nicht viel über Regexp im Multiline-Modus nachgedacht, bei dem $auch das Ende einer Zeile übereinstimmt. Tatsächlich würde es mit der leeren Zeichenfolge direkt vor der neuen Zeile übereinstimmen , sodass ein gewöhnliches Zeichen wie aniemals danach erscheinen kann $.

Hebelwirkung negative lookahead:

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

Diese RE ist ein Widerspruch und wird daher niemals mit irgendetwas übereinstimmen.

HINWEIS:
In Python fügt re.match () implizit \Aam Anfang des regulären Ausdrucks einen Zeichenfolgenanfang ( ) an. Dieser Anker ist wichtig für die Leistung: Ohne ihn wird die gesamte Zeichenfolge gescannt. Diejenigen, die Python nicht verwenden, möchten den Anker explizit hinzufügen:

\A(?!x)x

Eine, die vermisst wurde:

^\b$

Es kann nicht übereinstimmen, da die leere Zeichenfolge keine Wortgrenze enthält. In Python 2.5 getestet.

umschauen:

(?=a)b

Für Regex-Neulinge: Der positive Blick nach vorne (?=a)stellt sicher, dass das nächste Zeichen ist a, ändert jedoch nicht den Suchort (oder fügt das 'a' in die übereinstimmende Zeichenfolge ein). Nachdem das nächste Zeichen bestätigt wurde, stimmt ader verbleibende Teil von regex ( b) nur dann überein, wenn das nächste Zeichen ist b. Daher stimmt diese Regex nur überein, wenn ein Zeichen beide aund bgleichzeitig ist.

a\bc, wobei \bes sich um einen Ausdruck mit der Breite Null handelt, der der Wortgrenze entspricht.

Es kann nicht in der Mitte eines Wortes erscheinen, zu dem wir es zwingen.

$.

.^

$.^

(?!)

Maximale Übereinstimmung

a++a

Mindestens eine, agefolgt von einer beliebigen Anzahl a, ohne Rückverfolgung. Versuchen Sie dann, eine weitere zu findena .

oder Unabhängiger Unterausdruck

Dies entspricht dem Einfügen a+eines unabhängigen Unterausdrucks, gefolgt von einem anderen a.

(?>a+)a

Perl 5.10 unterstützt spezielle Steuerwörter namens "Verben", die der (*...)Reihe nach eingeschlossen sind. (Vergleiche mit einer (?...)speziellen Reihenfolge.) Darunter befindet sich auch das (*FAIL)Verb das sofort vom regulären Ausdruck zurückkehrt.

Beachten Sie, dass Verben kurz darauf auch in PCRE implementiert werden, sodass Sie sie auch in PHP oder anderen Sprachen mithilfe der PCRE-Bibliothek verwenden können. (Sie können jedoch nicht in Python oder Ruby. Sie verwenden ihre eigene Engine.)

\B\b

\b stimmt mit Wortgrenzen überein - die Position zwischen einem Buchstaben und einem Nichtbuchstaben (oder der Zeichenfolgengrenze).
\Bist seine Ergänzung - es entspricht der Position zwischen zwei Buchstaben oder zwischen Nichtbuchstaben.

Zusammen können sie keiner Position entsprechen.

Siehe auch:

• Wortgrenzen
• Dieses Muster passt nicht zu einigen Positionen
• Inspiration

Das scheint zu funktionieren:

$.

Wie wäre es $^oder vielleicht (?!)? 

Das schnellste wird sein:

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

'a' kann ein beliebiges nicht spezielles Zeichen sein ('x', 'y'). Die Implementierung von Knio ist vielleicht etwas reiner, aber diese ist schneller für alle Zeichenfolgen, die nicht mit dem von Ihnen ausgewählten Zeichen anstelle von 'a' beginnen, da sie in diesen Fällen nicht nach dem ersten Zeichen, sondern nach dem zweiten übereinstimmen.

Python wird es nicht akzeptieren, aber Perl wird:

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

Diese Regex sollte (theoretisch) versuchen, eine unendliche (gerade) Anzahl von ws zu finden, da die erste Gruppe (die ()s) in sich selbst rekursiv ist. Perl scheint keine Warnungen auszugeben, auch nicht unter use strict; use warnings;, daher gehe ich davon aus, dass es zumindest gültig ist und meine (minimalen) Tests mit nichts übereinstimmen, also reiche ich es für Ihre Kritik ein.

[^\d\D]oder (?=a)boder a$aodera^a

Dies funktioniert nicht für Python und viele andere Sprachen, ist jedoch in einem Javascript-Regex []eine gültige Zeichenklasse, die nicht zugeordnet werden kann. Folgendes sollte also sofort fehlschlagen, unabhängig von der Eingabe:

var noMatch = /^[]/;

Ich mag es besser als /$a/weil es mir klar seine Absicht kommuniziert. Und wann immer Sie es jemals brauchen würden, ich brauchte es, weil ich einen Fallback für ein dynamisch kompiliertes Muster brauchte, das auf Benutzereingaben basiert. Wenn das Muster ungültig ist, muss ich es durch ein Muster ersetzen, das mit nichts übereinstimmt. Vereinfacht sieht es so aus:

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

Alle Beispiele mit einem Boundary Matcher folgen demselben Rezept. Rezept:

1. Nehmen Sie einen der Boundary Matcher: ^, $, \ b, \ A, \ Z, \ z

2. Machen Sie das Gegenteil von dem, wofür sie bestimmt sind

Beispiele:

^ und \ A sind für den Anfang gedacht, verwenden Sie sie also nicht am Anfang

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

\ b stimmt mit einer Wortgrenze überein, verwenden Sie sie also dazwischen

\b --> .\b.

$, \ Z und \ z sind für das Ende gedacht, verwenden Sie sie also am Ende nicht

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

Andere beinhalten die Verwendung von Lookahead und Lookbehind, die ebenfalls mit der gleichen Analogie funktionieren: Wenn Sie einen positiven oder negativen Lookahead geben, gefolgt von etwas Gegenteiligem

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

Wenn Sie positiv oder negativ aussehen, folgen Sie etwas Gegenteiligem

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

Es könnte mehr solche Muster und mehr solche Analogien geben.

So viele gute Antworten!

Ähnlich wie bei @ nivks Antwort möchte ich den Leistungsvergleich für Perl für verschiedene Varianten von nie übereinstimmendem regulären Ausdruck teilen.

1. Eingabe: Pseudozufällige ASCII-Zeichenfolgen (25.000 verschiedene Zeilen, Länge 8-16):

Regex-Geschwindigkeit:

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. Eingabe: / usr / share / dict / words (100.000 englische Wörter).

Regex-Geschwindigkeit:

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 unter Intel i5-3320M, Linux-Kernel 4.13, Perl 5.26)

Ich glaube das

\Z RE FAILS! \A

deckt sogar Fälle ab, in denen der reguläre Ausdruck Flags wie MULTILINE, DOTALL usw. enthält.

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

Ich glaube (aber ich habe es nicht bewertet), dass unabhängig von der Länge (> 0) der Zeichenfolge zwischen \Zund \Adie Zeit bis zum Ausfall konstant sein sollte.

(*FAIL)

oder

(*F)

Mit PCRE und PERL können Sie dieses Backtracking-Steuerverb verwenden, das das Muster zum sofortigen Fehlschlagen zwingt.

Nachdem ich einige dieser großartigen Antworten gesehen hatte, veranlasste mich der Kommentar von @ arantius (in Bezug auf Timing $xvs x^vs (?!x)x) zu der aktuell akzeptierten Antwort, einige der bisher gegebenen Lösungen zeitlich festzulegen .

Unter Verwendung des 275k-Zeilenstandards von @ arantius habe ich die folgenden Tests in Python (v3.5.2, IPython 6.2.1) ausgeführt.

TL; DR: 'x^'und 'x\by'sind mit einem Faktor von mindestens ~ 16 die schnellsten und gehörten entgegen @ arantius 'Feststellung (?!x)xzu den langsamsten (~ 37-mal langsamer). Die Geschwindigkeitsfrage ist also sicherlich implementierungsabhängig. Testen Sie es selbst auf Ihrem vorgesehenen System, bevor Sie festlegen, ob Geschwindigkeit für Sie wichtig ist.

UPDATE: Es gibt anscheinend eine große Diskrepanz zwischen Timing 'x^'und 'a^'. Weitere Informationen finden Sie in dieser Frage und in der vorherigen Bearbeitung für die langsameren Timings mit aanstelle von 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)

Als ich dies zum ersten Mal ausführte, vergaß ich, rdie letzten drei Ausdrücke zu vergessen, und wurde daher als Rücktaste '\b'interpretiert '\x08'. Zu meiner Überraschung war es 'a\x08c'jedoch schneller als das bisher schnellste Ergebnis! Um fair zu sein, es wird immer noch zu diesem Text passen, aber ich dachte, es wäre immer noch erwähnenswert, weil ich nicht sicher bin, warum es schneller ist.

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

Meine Testdatei wurde mit einer Formel für "... lesbare Inhalte und keine doppelten Zeilen" (unter Ubuntu 16.04) erstellt:

$ 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

Leere Regex

Der beste reguläre Ausdruck, der niemals mit etwas übereinstimmt, ist ein leerer regulärer Ausdruck. Aber ich bin nicht sicher, ob alle Regex-Engines das akzeptieren werden.

Unmöglicher Regex

Die andere Lösung besteht darin, einen unmöglichen regulären Ausdruck zu erstellen. Ich habe festgestellt, dass $-^die Berechnung unabhängig von der Größe Ihres Textes nur zwei Schritte dauert ( https://regex101.com/r/yjcs1Z/1 ).

Als Referenz:

• $^und $.mache 36 Schritte, um zu berechnen -> O (1)
• \b\B macht 1507 Schritte in meinem Sample und erhöht sich mit der Anzahl der Zeichen in Ihrer Zeichenfolge -> O (n)

Populärer Thread zu dieser Frage:

• Regex, um * keinen * Zeichen zu entsprechen

Vielleicht das?

/$.+^/

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

und ... durch alle druckbaren Symbole ersetzen;). Das ist für eine Textdatei.

Was ist mit anstelle von Regex, verwenden Sie einfach eine immer falsche if-Anweisung? In Javascript:

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

Eine tragbare Lösung, die nicht von der Regexp-Implementierung abhängt, besteht darin, nur eine konstante Zeichenfolge zu verwenden, von der Sie sicher sind, dass sie niemals in den Protokollnachrichten angezeigt wird. Erstellen Sie beispielsweise eine Zeichenfolge, die auf Folgendem basiert:

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

Sicher, dies ist keine intellektuelle Herausforderung, sondern eher eine Klebebandprogrammierung .

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

Erstellt ein Muster, das nur alphanumerische Zeichen und ' -' enthält (keines davon sind Regex-Sonderzeichen), aber es ist statistisch unmöglich, dass dieselbe Zeichenfolge irgendwo zuvor angezeigt wurde (da dies der springende Punkt einer GUID ist.)