Regex yang tidak akan pernah cocok dengan apa pun

Ini mungkin terdengar seperti pertanyaan bodoh, tapi saya sudah lama berbicara dengan beberapa rekan pengembang saya dan itu terdengar seperti hal yang menyenangkan untuk dipikirkan.

Begitu; apa pendapat Anda - seperti apa tampilan Regex, yang tidak akan pernah bisa ditandingi oleh string apa pun!

Sunting : Mengapa saya menginginkan ini? Yah, pertama karena saya merasa menarik untuk memikirkan ungkapan seperti itu dan kedua karena saya membutuhkannya untuk naskah.

Dalam skrip itu saya mendefinisikan kamus sebagai Dictionary<string, Regex>. Ini berisi, seperti yang Anda lihat, string dan ekspresi.

Berdasarkan kamus itu saya membuat metode yang semuanya menggunakan kamus ini hanya sebagai referensi tentang bagaimana mereka harus melakukan pekerjaan mereka, salah satunya cocok dengan regex terhadap file log yang diuraikan.

Jika suatu ekspresi cocok, yang lain Dictionary<string, long> ditambahkan nilai yang dikembalikan oleh ekspresi. Jadi, untuk menangkap pesan log apa pun yang tidak cocok dengan ekspresi dalam kamus saya membuat grup baru yang disebut "tidak dikenal".

Untuk grup ini segala sesuatu yang tidak cocok dengan yang lain ditambahkan. Tetapi untuk mencegah ekspresi "tidak diketahui" menjadi ketidakcocokan (secara tidak sengaja) pesan-log, saya harus membuat ekspresi yang paling tidak pernah cocok, tidak peduli string apa pun yang saya berikan.

Jadi, di sana Anda punya alasan saya untuk ini "bukan pertanyaan nyata" ...

Ini sebenarnya cukup sederhana, meskipun tergantung pada implementasi / flag *:

$a

Akan cocok dengan karakter asetelah akhir string. Semoga berhasil.

PERINGATAN:
Ungkapan ini mahal - itu akan memindai seluruh baris, menemukan jangkar end-of-line, dan hanya kemudian tidak menemukan adan mengembalikan kecocokan negatif. (Lihat komentar di bawah untuk detail lebih lanjut.)

^* Awalnya saya tidak terlalu memikirkan regexp mode multiline, di mana $juga cocok dengan akhir baris. Bahkan, itu akan cocok dengan string kosong tepat sebelum baris baru , jadi karakter biasa seperti atidak pernah bisa muncul setelahnya $.

Leverage negative lookahead:

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

RE ini merupakan kontradiksi dalam hal dan karenanya tidak akan pernah cocok dengan apa pun.

CATATAN:
Dalam Python, re.match () secara implisit menambahkan anchor awal-dari-string (\A ) ke awal ekspresi reguler. Jangkar ini penting untuk kinerja: tanpa itu, seluruh string akan dipindai. Mereka yang tidak menggunakan Python ingin menambahkan jangkar secara eksplisit:

\A(?!x)x

Salah satu yang terlewatkan:

^\b$

Itu tidak bisa cocok karena string kosong tidak mengandung batas kata. Diuji dalam Python 2.5.

lihat sekeliling:

(?=a)b

Untuk pemula regex: Tampilan positif di depan (?=a)memastikan bahwa karakter berikutnya adalah a, tetapi tidak mengubah lokasi pencarian (atau menyertakan 'a' dalam string yang cocok). Sekarang karakter berikutnya dikonfirmasikan sebagai a, bagian yang tersisa dari regex ( b) cocok hanya jika karakter berikutnya b. Dengan demikian, regex ini cocok hanya jika karakter adalah baik adan bpada saat yang sama.

a\bc, di mana \bekspresi nol-lebar yang cocok dengan batas kata.

Itu tidak dapat muncul di tengah kata, yang kami paksa.

$.

.^

$.^

(?!)

Pencocokan maksimal

a++a

Setidaknya satu adiikuti oleh sejumlah a, tanpa mundur. Kemudian cobalah untuk mencocokkan satu lagi a.

atau sub ekspresi Independen

Ini sama dengan menempatkan a+dalam sub ekspresi independen, diikuti oleh yang lain a.

(?>a+)a

Perl 5.10 mendukung kata-kata kontrol khusus yang disebut "kata kerja", yang tertutup secara (*...)berurutan. (Bandingkan dengan (?...)urutan khusus.) Di antara mereka, itu termasuk (*FAIL)kata kerja yang segera kembali dari ekspresi reguler.

Perhatikan bahwa kata kerja juga diterapkan di PCRE segera setelah itu, sehingga Anda dapat menggunakannya dalam PHP atau bahasa lain menggunakan pustaka PCRE juga. (Namun, Anda tidak bisa menggunakan Python atau Ruby. Mereka menggunakan mesin mereka sendiri.)

\B\b

\bcocok dengan batas kata - posisi antara huruf dan huruf (atau batas string).
\Badalah pelengkapnya - ini cocok dengan posisi antara dua huruf atau antara non-huruf.

Bersama-sama mereka tidak dapat menandingi posisi apa pun.

Lihat juga:

• Batas Kata
• Pola ini tidak cocok dengan beberapa posisi
• Inspirasi

Ini sepertinya berhasil:

$.

Bagaimana dengan $^atau mungkin (?!)? 

Yang tercepat adalah:

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

'a' dapat berupa karakter non-khusus ('x', 'y'). Implementasi Knio mungkin sedikit lebih murni tetapi yang ini akan lebih cepat untuk semua string yang tidak dimulai dengan karakter apa pun yang Anda pilih alih-alih 'a' karena itu tidak akan cocok dengan karakter pertama daripada setelah yang kedua dalam kasus tersebut.

Python tidak akan menerimanya, tetapi Perl akan:

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

Regex ini harus (secara teoritis) mencoba untuk mencocokkan jumlah tak terhingga ( datar ) dari ws, karena grup pertama ( ()s) muncul kembali dengan sendirinya. Perl tampaknya tidak mengeluarkan peringatan apa pun, bahkan di bawah use strict; use warnings;, jadi saya menganggap itu setidaknya valid, dan pengujian saya (minimal) gagal mencocokkan apa pun, jadi saya kirimkan untuk kritik Anda.

[^\d\D]atau (?=a)batau a$aataua^a

Ini tidak akan berfungsi untuk Python, dan banyak bahasa lainnya, tetapi dalam regex Javascript, []adalah kelas karakter yang valid yang tidak dapat dicocokkan. Jadi yang berikut ini harus segera gagal, apa pun inputnya:

var noMatch = /^[]/;

Saya menyukainya lebih baik daripada /$a/karena bagi saya, itu jelas menyampaikan maksudnya. Dan ketika Anda membutuhkannya, saya membutuhkannya karena saya membutuhkan cadangan untuk pola yang disusun secara dinamis berdasarkan input pengguna. Ketika polanya tidak valid, saya harus menggantinya dengan pola yang tidak cocok dengan apa pun. Sederhana, terlihat seperti ini:

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

Semua contoh yang melibatkan pencocokan batas mengikuti resep yang sama. Resep:

1. Ambil salah satu pencocokan batas: ^, $, \ b, \ A, \ Z, \ z

2. Bertentangan dengan apa yang dimaksudkan untuk mereka

Contoh:

^ dan \ A dimaksudkan untuk permulaan jadi jangan menggunakannya di awal

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

\ b cocok dengan batas kata jadi gunakan di antaranya

\b --> .\b.

$, \ Z dan \ z dimaksudkan untuk yang terakhir jadi jangan gunakan pada akhirnya

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

Lainnya melibatkan penggunaan lookahead dan lookbehind yang juga bekerja dengan analogi yang sama: Jika Anda memberikan lookahead positif atau negatif diikuti oleh sesuatu yang berlawanan

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

Jika Anda memberikan tampilan positif atau negatif di belakang mengikuti sesuatu yang berlawanan

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

Mereka bisa lebih seperti pola dan analoginya.

Begitu banyak jawaban bagus!

Mirip dengan jawaban @ nivk, saya ingin berbagi perbandingan kinerja untuk Perl untuk berbagai varian regex yang tidak pernah cocok.

1. Input: string ascii pseudo-acak (25.000 baris berbeda, panjang 8-16):

Kecepatan regex:

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. Input: / usr / share / dikt / kata (100.000 kata bahasa Inggris).

Kecepatan regex:

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

aku percaya itu

\Z RE FAILS! \A

bahkan mencakup kasus-kasus di mana ekspresi reguler termasuk bendera seperti MULTILINE, DOTALL dll.

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

Saya percaya (tapi saya belum membandingkannya) bahwa berapa pun panjang (> 0) dari string antara \Zdan \A, waktu ke kegagalan harus konstan.

(*FAIL)

atau

(*F)

Dengan PCRE dan PERL Anda dapat menggunakan kata kerja kontrol penelusuran ulang ini yang memaksa pola untuk gagal dengan segera.

Setelah melihat beberapa jawaban hebat ini, komentar @ arantius (mengenai waktu $xvs x^vs (?!x)x) pada jawaban yang diterima saat ini membuat saya ingin mengatur waktu beberapa solusi yang diberikan sejauh ini.

Menggunakan standar garis 275k @ arantius, saya menjalankan tes berikut dengan Python (v3.5.2, IPython 6.2.1).

TL; DR: 'x^'dan 'x\by'yang tercepat dengan faktor setidaknya ~ 16, dan bertentangan dengan temuan @ arantius, (?!x)xtermasuk yang paling lambat (~ 37 kali lebih lambat). Jadi pertanyaan kecepatan tentu tergantung implementasi. Uji sendiri pada sistem yang Anda inginkan sebelum melakukan apakah kecepatan penting bagi Anda.

PEMBARUAN: Rupanya ada perbedaan besar antara waktu 'x^'dan'a^' . Silakan lihat pertanyaan ini untuk info lebih lanjut, dan sebelumnya mengedit untuk timing lebih lambat dengan abukan 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)

Pertama kali saya menjalankan ini, saya lupa r aw 3 ekspresi terakhir, jadi '\b'ditafsirkan sebagai '\x08', karakter backspace. Namun, yang mengejutkan saya, 'a\x08c'ternyata lebih cepat dari hasil tercepat sebelumnya! Agar adil, itu masih akan cocok dengan teks itu, tapi saya pikir itu masih perlu dicatat karena saya tidak yakin mengapa itu lebih cepat.

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

File pengujian saya dibuat menggunakan rumus untuk "... Konten yang Dapat Dibaca Dan Tidak Ada Garis Duplikat" (di 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

Regex kosong

Regex terbaik untuk tidak pernah cocok dengan apa pun adalah regex kosong. Tapi saya tidak yakin semua mesin regex akan menerimanya.

Regex yang tidak mungkin

Solusi lainnya adalah membuat regex yang tidak mungkin. Saya menemukan bahwa $-^hanya perlu dua langkah untuk menghitung terlepas dari ukuran teks Anda ( https://regex101.com/r/yjcs1Z/1 ).

Sebagai referensi:

• $^ dan $. ambil 36 langkah untuk menghitung -> O (1)
• \b\B mengambil 1507 langkah pada sampel saya dan meningkat dengan jumlah karakter di string Anda -> O (n)

Utas yang lebih populer tentang pertanyaan ini:

• Regex ke * tidak * cocok dengan karakter apa pun

Mungkin ini?

/$.+^/

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

dan ganti ... dengan semua simbol yang dapat dicetak;). Itu untuk file teks.

Bagaimana dengan alih-alih regex, gunakan saja statemen if false? Dalam javascript:

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

Solusi portabel yang tidak akan bergantung pada implementasi regexp adalah dengan hanya menggunakan string konstan yang Anda yakin tidak akan pernah muncul dalam pesan log. Misalnya membuat string berdasarkan pada yang berikut:

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

Tentu, ini bukan tantangan intelektual, tetapi lebih seperti pemrograman lakban .

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

Membuat pola yang hanya berisi alfanumerik dan ' -' (tidak ada yang merupakan karakter khusus regex) tetapi secara statistik tidak mungkin string yang sama muncul di mana saja sebelumnya (karena itulah inti dari GUID.)