아무것도 일치하지 않는 정규식

이것은 어리석은 질문처럼 들릴지 모르지만 동료 개발자들과 오랫동안 이야기를 나누었으며 재미있는 생각처럼 들렸습니다.

그래서; 당신의 생각은 무엇입니까-Regex는 어떻게 생겼으며, 어떤 문자열과도 일치하지 않습니다!

편집 : 왜 내가 이것을 원합니까? 글쎄, 첫 번째는 그런 표현을 생각하는 것이 흥미롭고 두 번째는 스크립트에 필요하기 때문입니다.

그 스크립트에서 나는 사전을 다음과 같이 정의합니다. Dictionary<string, Regex> . 여기에는 문자열과 표현식이 포함되어 있습니다.

해당 사전을 기반으로 모든 사람이 작업을 수행하는 방법에 대한 참조로만이 사전을 사용하는 메소드를 작성합니다.이 중 하나는 구문 분석 된 로그 파일에 대한 정규식과 일치합니다.

식이 일치하면 다른 식 Dictionary<string, long> 하면 식에 의해 반환되는 값이 추가됩니다. 따라서 사전의 식과 일치하지 않는 로그 메시지를 포착하기 위해 "unknown"이라는 새 그룹을 만들었습니다.

이 그룹에는 다른 것과 일치하지 않는 모든 것이 추가됩니다. 그러나 "알 수없는"식이 실수로 로그 메시지와 일치하지 않도록하려면 문자열에 관계없이 가장 확실하게 일치하지 않는 식을 만들어야했습니다.

따라서, 당신은이 "진짜 질문이 아닙니다"에 대한 나의 이유가 있습니다 ...

구현 / 플래그 * 에 따라 다르지만 실제로는 매우 간단합니다 .

$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 는 정규 표현식의 시작 부분에 문자열 시작 앵커 ( )를 암시 적으로 추가합니다 . 이 앵커는 성능에 중요합니다.이 앵커가 없으면 전체 문자열이 스캔됩니다. 파이썬을 사용하지 않는 사람들은 앵커를 명시 적으로 추가하려고합니다.

\A(?!x)x

놓친 것 :

^\b$

빈 문자열에 단어 경계가 없기 때문에 일치하지 않습니다. 파이썬 2.5에서 테스트되었습니다.

둘러보세요 :

(?=a)b

정규 표현식 초보자의 경우 : 긍정적 인 모습 (?=a)은 다음 문자가 a이지만 검색 위치를 변경하지는 않습니다 (또는 일치하는 문자열에 'a'포함). 이제 다음 문자가 확인 a되었으므로 b다음 문자가있는 경우에만 정규식 ( ) 의 나머지 부분이 일치합니다 b. 따라서이 정규 표현식은 문자가 모두있는 경우에만 일치 a와 b동시에.

a\bc여기서 \b단어 경계와 일치하는 너비가 0 인 표현식입니다.

그것은 단어의 한가운데서 나타날 수 없으며, 우리는 그것을 강요합니다.

$.

.^

$.^

(?!)

최대 매칭

a++a

역 추적없이 최소 하나 a뒤에 임의의 숫자가옵니다 a. 그런 다음 하나 더 일치 시키십시오 a.

또는 독립적 하위 표현

이것은 a+독립적 인 하위 표현식을 입력 한 다음 다른 하위 표현식을 입력하는 것과 같습니다 a.

(?>a+)a

Perl 5.10은 "동사"라는 특수 제어 단어를 지원하며 (*...)순서대로 묶습니다 . ( (?...)특수 순서 와 비교하십시오 .) 그중에 는 정규 표현식에서 즉시 리턴 하는 (*FAIL)동사 가 포함되어 있습니다.

동사는 PCRE에서도 곧 구현되므로 PCRE 라이브러리를 사용하여 PHP 또는 다른 언어로도 사용할 수 있습니다. (그러나 파이썬이나 루비에서는 사용할 수 없습니다. 그들은 자체 엔진을 사용합니다.)

\B\b

\b단어 경계-문자 사이의 위치와 문자가 아닌 문자 (또는 문자열 경계)와 일치합니다.
\B그것의 보완-그것은 두 글자 사이 또는 비 문자 사이의 위치와 일치합니다.

함께 그들은 어떤 위치와도 일치 할 수 없습니다.

또한보십시오:

• 단어 경계
• 이 패턴은 일부 위치와 일치하지 않습니다
• 영감

이것은 작동하는 것 같습니다 :

$.

어때 $^아니면 (?!)? 

가장 빠른 방법은 다음과 같습니다.

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

'a'는 특수 문자가 아닌 문자 ( 'x', 'y') 일 수 있습니다. Knio의 구현은 조금 더 순수 할 수 있지만 'a'대신 선택한 문자로 시작하지 않는 모든 문자열에 대해 더 빠를 것입니다.이 경우 첫 번째 문자 이후가 아니라 첫 번째 문자 이후에 일치하지 않기 때문입니다.

파이썬은 그것을 받아들이지 않을 것이지만 Perl은 :

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

이 정규식은 (이론적으로) 무한한 (짝수)의 수와 일치해야 w합니다. 첫 번째 그룹 ( ()들)은 그 자체로 되풀이되기 때문입니다. Perl은 아래에서도 경고를 발행하지 않는 것 같습니다 use strict; use warnings;. 최소한 유효하다고 가정하고 내 (최소) 테스트가 일치하지 않으므로 비평을 위해 제출하십시오.

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

이것은 파이썬 및 다른 많은 언어에서는 작동하지 않지만 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.

다른 사람들은 lookahead와 lookbehind를 사용하여 동일한 비유로도 작동합니다.

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

당신이 반대 무언가를 따라 긍정적 또는 부정적 외모를 주면

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

그것들은 더 많은 패턴과 더 많은 유사점이 될 수 있습니다.

많은 좋은 답변!

@nivk의 답변과 유사하게 절대 일치하지 않는 정규 표현식의 다른 변형에 대해 Perl의 성능 비교를 공유하고 싶습니다.

1. 입력 : 의사 랜덤 아스키 문자열 (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

(인텔 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의 의견 (timing $xvs x^vs (?!x)x)은 지금까지 주어진 솔루션 중 일부를 시간을 내고 싶습니다.

@arantius의 275k 라인 표준을 사용하여 Python (v3.5.2, IPython 6.2.1)에서 다음 테스트를 실행했습니다.

TL; DR : 'x^'및'x\by' @ arantius의 발견에 적어도 ~ 16의 요소, 그리고 반대하여 가장 빠르다, (?!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)

처음으로 이것을 실행했을 때, 나는 r마지막 3 개의 표현을 잊어 버렸습니다 . 그래서 백 스페이스 문자 '\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

내 테스트 파일은 "... 읽기 쉬운 내용과 중복 된 줄 없음" (우분투 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 ).

참고로 :

• $^및 $.(1)> O를 - 계산하는 단계 (36)를 가지고
• \b\B 내 샘플에서 1507 단계를 거치고 문자열의 문자 수에 따라 증가합니다-> O (n)

이 질문에 대한 더 인기있는 스레드 :

• 모든 문자와 일치하지 않는 * 정규 표현식

어쩌면?

/$.+^/

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

...을 모든 인쇄 가능한 기호로 대체하십시오.). 그것은 텍스트 파일입니다.

정규 표현식 대신 항상 false if 문을 사용하면 어떻습니까? 자바 스크립트에서 :

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

정규 표현식 구현에 의존하지 않는 휴대용 솔루션은 로그 메시지에 절대 나타나지 않는 상수 문자열을 사용하는 것입니다. 예를 들어 다음을 기반으로 문자열을 만듭니다.

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의 요점이므로 동일한 문자열이 이전 어느 곳에 나 나타나는 것은 통계적으로 불가능합니다.