一个正则表达式，永远不会与任何事物匹配

这听起来像是一个愚蠢的问题，但是我与一些开发人员进行了长时间的交谈，这听起来像是一件有趣的事情。

所以; 您的想法是什么-正则表达式看起来像什么，永远不会被任何字符串匹配！

编辑：为什么我要这个？好吧，首先是因为我觉得思考这样的表达式很有趣，其次是因为我需要用于脚本。

在该脚本中，我将字典定义为Dictionary<string, Regex>。如您所见，它包含一个字符串和一个表达式。

基于该字典，我创建了全部使用此字典作为其工作方式参考的方法，其中一种将正则表达式与已解析的日志文件进行匹配。

如果一个表达式匹配，Dictionary<string, long>则为另一个表达式添加一个由表达式返回的值。因此，为了捕获字典中某个表达式不匹配的所有日志消息，我创建了一个名为“未知”的新组。

在这个组中，添加了其他所有不匹配的内容。但是为了防止“未知”表达式与日志消息不匹配（偶然），我必须创建一个表达式，该表达式无论从我提供的字符串来看，都绝不会匹配。

因此，您有理由提出这个“不是真正的问题” ...

这实际上很简单，尽管它取决于实现/标志 *：

$a

将a在字符串末尾匹配一个字符。祝好运。

警告：
此表达式很昂贵-它将扫描整行，找到行尾锚，然后才找到a并返回负匹配。（有关更多详细信息，请参见下面的评论。）

^*最初，我对多行模式正则表达式没有多加考虑，因为它$也与行尾匹配。实际上，它将与换行符之前的空字符串匹配，因此，像这样的普通字符a永远不会出现在之后$。

杠杆作用negative lookahead：

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

此RE在术语上是矛盾的，因此永远不会匹配任何内容。

注意：
在Python中，re.match（）会\A在正则表达式的开头隐式添加字符串的开始锚点（）。此锚对于性能很重要：如果没有锚，将扫描整个字符串。那些不使用Python的人将希望显式添加锚点：

\A(?!x)x

错过了一个：

^\b$

它不匹配，因为空字符串不包含单词边界。在Python 2.5中测试。

看看周围：

(?=a)b

对于正则表达式新手：正面看(?=a)要确保下一个字符为a，但不会更改搜索位置（或在匹配的字符串中包含'a'）。现在，确认下一个字符为a，b仅当下一个字符为时，regex（）的其余部分才匹配b。因此，此正则表达式匹配只有一个字符既a与b在同一时间。

a\bc，其中\b是一个与单词边界匹配的零宽度表达式。

它不能出现在单词的中间，我们强迫它出现。

$.

.^

$.^

(?!)

最大匹配

a++a

至少一个，a后跟任意数量a的，无回溯。然后尝试再匹配一个a。

或独立子表达式

这等效于放入a+一个独立的子表达式，后跟另一个a。

(?>a+)a

Perl 5.10支持称为“动词”的特殊控制词，这些词按(*...)顺序包含在其中。（与(?...)特殊序列比较。）其中包括(*FAIL)动词，该动词立即从正则表达式返回。

请注意，动词也在不久后在PCRE中实现，因此您也可以通过PCRE库在PHP或其他语言中使用它们。（但是，您不能使用Python或Ruby。它们使用自己的引擎。）

\B\b

\b匹配单词边界-字母和非字母之间的位置（或字符串边界）。
\B是它的补码-它匹配两个字母之间或非字母之间的位置。

它们在一起不能匹配任何位置。

也可以看看：

• 词边界
• 此模式与几个位置不匹配
• 灵感

这似乎可行：

$.

如何$^或可能(?!)？ 

最快的将是：

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

“ a”可以是任何非特殊字符（“ x”，“ y”）。Knio的实现可能会更纯净，但是对于所有不以您选择的任何字符开头而不是'a'开头的字符串来说，这种方法都会更快，因为在这种情况下，它不会匹配第一个字符而不是第二个字符。

Python不会接受它，但是Perl会：

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

这个正则表达式应该（理论上）尝试匹配无限（偶数）个ws，因为第一组（()s）递归到自身中。Perl似乎没有发出任何警告，即使在之下use strict; use warnings;也是如此，因此我认为它至少是有效的，并且我的（最低）测试无法匹配任何内容，因此我将其提交给您进行批评。

[^\d\D]或(?=a)b或a$a或a^a

这不适用于Python和许多其他语言，但是在Javascript正则表达式中，[]是无法匹配的有效字符类。因此，无论输入什么，以下内容应立即失败：

var noMatch = /^[]/;

我更喜欢它，而不是/$a/因为它对我来说清楚地传达了它的意图。至于何时需要它，我就需要它，因为我需要一个基于用户输入的动态编译模式的后备。当模式无效时，我需要将其替换为不匹配的模式。简化后，它看起来像这样：

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

所有涉及边界匹配器的示例都遵循相同的配方。食谱：

1. 取任意边界匹配器：^，$，\ b，\ A，\ Z，\ z

2. 违背他们的意图

例子：

^和\ A是用于开始的，因此不要在开始时使用它们

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

\ b匹配单词边界，因此请在两者之间使用

\b --> .\b.

$，\ Z和\ z用于结尾，所以不要在最后使用它们

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

其他涉及先行和后向的使用，它们也可以使用相同的类比：如果您给出正向或负向先行，然后进行相反的操作

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

如果您按照相反的方向进行正向或负向回望

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

他们可能更多是这样的模式和更多这样的类比。

这么多好的答案！

与@nivk的答案类似，我想分享Perl对于永不匹配的正则表达式的不同变体的性能比较。

1. 输入：伪随机ASCII字符串（25,000条不同的行，长度为8-16）：

正则表达式速度：

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. 输入：/ usr / share / dict / words（100,000个英语单词）。

正则表达式速度：

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在Intel i5-3320M，Linux内核4.13，Perl 5.26上）

我相信

\Z RE FAILS! \A

甚至涵盖了正则表达式包含MULTILINE，DOTALL等标志的情况。

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

我相信（但我尚未对其进行基准测试），无论\Zand与之间的字符串的长度（> 0）如何\A，失效时间都应该是恒定的。

(*FAIL)

要么

(*F)

通过PCRE和PERL，您可以使用此回溯控制动词来强制模式立即失败。

在看到了一些很好的答案之后，@ arantius对当前接受的答案的评论（关于时间$x与x^vs (?!x)x）使我想安排到目前为止给出的一些解决方案的时间。

使用@arantius的275k行标准，我在Python（v3.5.2，IPython 6.2.1）中运行了以下测试。

TL; DR：'x^'和'x\by'最快的速度至少约为16，与@arantius的发现相反，它(?!x)x是最慢的（约为慢 37倍）。因此速度问题当然取决于实现方式。如果速度对您来说很重要，请在承诺的系统上进行测试。

更新：时序'x^'和之间显然存在很大差异'a^'。请参阅此问题以获取更多信息，以及有关较慢时间的以前的编辑，请参见a代替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)

第一次运行此命令时，我忘记了raw的最后三个表达式，因此'\b'被解释为'\x08'退格字符。但是，令我惊讶的是'a\x08c'它比以前最快的结果要快！公平地说，它仍然会与该文本匹配，但是我认为仍然值得一提，因为我不确定为什么它会更快。

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

我的测试文件是使用“ ...可读内容且无重复行”的公式创建的（在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

空正则表达式

绝不匹配任何东西的最佳正则表达式是空正则表达式。但是我不确定所有的正则表达式引擎都接受。

不可能的正则表达式

另一个解决方案是创建一个不可能的正则表达式。我发现$-^无论文本大小如何（https://regex101.com/r/yjcs1Z/1），只需执行两个步骤即可进行计算。

以供参考：

• $^并$.采取36步计算-> O（1）
• \b\B 对我的样本执行1507步，并随着字符串中字符数的增加-> O（n）

关于这个问题的更多热门话题：

• 正则表达式不匹配任何字符

也许这个吗？

/$.+^/

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

并用所有可打印符号替换...;）。那是一个文本文件。

代替正则表达式，只使用始终为false的if语句呢？在javascript中：

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

一个不依赖于regexp实现的可移植解决方案是仅使用一个确定不会在日志消息中出现的常量字符串。例如，根据以下内容创建一个字符串：

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

当然，这不是理智上的挑战，而是更像管道胶带编程。

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

创建一个仅包含字母数字和' -'（均不是正则表达式特殊字符）的模式，但是从统计学上讲，同一字符串以前不可能出现在任何地方（因为这是GUID的全部内容）。