Regex 正则表达式以匹配不带'；一个字也没有_Regex_Regex Negation

Regex 正则表达式以匹配不带'；一个字也没有

regex

Regex 正则表达式以匹配不带'；一个字也没有,regex,regex-negation,Regex,Regex Negation,我知道可以匹配一个单词，然后使用其他工具（例如grep-v）反向匹配。但是，是否可以使用正则表达式匹配不包含特定单词的行，例如hede 输入：代码：如果您只是将其用于grep，那么可以使用grep-vhede来获取所有不包含hede的行哦，重读这个问题，grep-v可能就是你所说的“工具选项”的意思。以下是否定任意正则表达式不容易的原因。不过，我必须同意其他答案：如果这不是一个假设问题，那么正则表达式就不是正确的选择。正则表达式不支持反向匹配的概念并不完全正确。您可以通过使用负面环视来模拟

我知道可以匹配一个单词，然后使用其他工具（例如

grep-v

）反向匹配。但是，是否可以使用正则表达式匹配不包含特定单词的行，例如

hede

输入：代码：如果您只是将其用于grep，那么可以使用

grep-vhede

来获取所有不包含hede的行

哦，重读这个问题，

grep-v

可能就是你所说的“工具选项”的意思。

以下是否定任意正则表达式不容易的原因。不过，我必须同意其他答案：如果这不是一个假设问题，那么正则表达式就不是正确的选择。

正则表达式不支持反向匹配的概念并不完全正确。您可以通过使用负面环视来模拟此行为：

^((?!hede).)*$

上面的正则表达式将匹配包含（子）字符串“hede”的任何字符串或不带换行符的行。如前所述，这不是正则表达式“擅长”的（或应该做的），但仍然是可能的

如果还需要匹配换行符，请使用（以下模式中的尾随

）：

或者内联使用：

/(?s)^((?!hede).)*$/

（其中，

/…/

是正则表达式分隔符，即不是模式的一部分）

如果DOT-ALL修饰符不可用，则可以模拟字符类的相同行为

[\s\s]

：

/^((?!hede)[\s\S])*$/

解释字符串只是

字符的列表。每个字符前后都有一个空字符串。因此

字符列表将具有

n+1

空字符串。考虑字符串<代码>“abHeDeD”< /代码>：

其中，

是空字符串。正则表达式

（？！hede）。

向前看，看是否没有子字符串

“hede”

，如果是这种情况（因此看到了其他内容），则

（点）将匹配除换行符以外的任何字符。环视也被称为零宽度断言，因为它们不使用任何字符。他们只是断言/验证某些东西

因此，在我的示例中，首先验证每个空字符串，以查看前面是否没有

“hede”

，然后再由

（点）使用字符。regex

（？！hede）。

将只执行一次，因此它被包装在一个组中，并重复零次或多次：

（？！hede）。*

。最后，锚定输入的开始和结束，以确保使用整个输入：

^（（？！hede）。*$

如您所见，输入

“ABhedeCD”

将失败，因为在

e3

上，regex

（？！hede）

失败（前面有

“hede”

）。

不是regex，但我发现将串行grep与管道一起使用以消除噪声是合乎逻辑且有用的

搜索一个apache配置文件，不带所有注释-

grep -v '\#' /opt/lampp/etc/httpd.conf      # this gives all the non-comment lines

及

序列grep的逻辑是（不是注释）和（匹配dir）

注意，的解决方案不是以“hede”开头的。：

^(?!hede).*$

^((?!hede).)*$

通常比不包含“hede”的解决方案更有效：

^(?!hede).*$

^((?!hede).)*$

前者只在输入字符串的第一个位置检查“hede”，而不是在每个位置。给出的答案非常好，只是一个学术观点：
理论计算机科学意义上的正则表达式不能这样做。对他们来说，它必须看起来像这样：

^([^h].*$)|(h([^e].*$|$))|(he([^h].*$|$))|(heh([^e].*$|$))|(hehe.+$)

这只是一个完整的匹配。如果要对子匹配执行此操作，则会更加尴尬。
如果要匹配一个字符以否定一个类似于否定字符类的单词，请执行以下操作：
例如，字符串：

<? $str="aaa bbb4 aaa bbb7"; ?>

如果希望正则表达式测试仅在整个字符串匹配时失败，则以下操作将起作用：

^(?!hede$).*
e、 g.--如果要允许除“foo”之外的所有值（即“foofoo”、“barfoo”和“foobar”将通过，但“foo”将失败），请使用：
^（？！foo$）.
当然，如果要检查精确相等性，在这种情况下更好的一般解决方案是检查字符串相等性，即

myStr !== 'foo'
如果需要任何正则表达式特性（这里是不区分大小写和范围匹配），甚至可以将否定放在测试之外：

但是，在需要进行正正则表达式测试（可能是API测试）的情况下，此答案顶部的正则表达式解决方案可能会有所帮助。
因此，您可以避免对每个位置进行前瞻性测试：

/^(?:[^h]+|h++(?!ede))*+$/
相当于（对于.net）：
旧答案：

/^(?>[^h]+|h+(?!ede))*$/
OP没有指定或标记post以指示正则表达式将在其中使用的上下文（编程语言、编辑器、工具）
对我来说，有时我需要在使用Textpad编辑文件时执行此操作
Textpad
支持一些正则表达式，但不支持向前看或向后看，因此需要几个步骤
如果我希望保留所有不包含字符串hede的行，我会这样做：

^([^h].*$)|(h([^e].*$|$))|(he([^h].*$|$))|(heh([^e].*$|$))|(hehe.+$)
一,。搜索/替换整个文件，在包含任何文本的每行开头添加唯一的“标记”

三,。此时，所有剩余的行不包含字符串hede
。从所有行中删除唯一的“标记”（替换字符串为空）：

二,。对于包含字符串hede的所有行，请删除唯一的“标记”：

我是这样做的：

^[^h]*(h(?!ede)[^h]*)*$

比其他答案更准确、更有效。它实现了弗里德尔的“展开循环”效率技术，并且需要更少的回溯。
答案：

^((?!hede).)*$
说明：

^((?!hede).)*$

^
字符串的开头，
（
分组并捕获到\1（0次或更多次（匹配尽可能多的数量）），

（？）< myStr !== 'foo' !/^[a-f]oo$/i.test(myStr) /^(?:[^h]+|h++(?!ede))*+$/ ^(?>(?:[^h]+|h+(?!ede))*)$ /^(?>[^h]+|h+(?!ede))*$/ Search string:^(.) Replace string:<@#-unique-#@>\1 Replace-all Search string:<@#-unique-#@>.*hede.*\n Replace string:<nothing> Replace-all Search string:<@#-unique-#@> Replace string:<nothing> Replace-all Search string:^(.) Replace string:<@#-unique-#@>\1 Replace-all Search string:<@#-unique-#@>(.*hede) Replace string:\1 Replace-all Search string:<@#-unique-#@> Replace string:<nothing> Replace-all ^[^h]*(h(?!ede)[^h]*)*$ ^((?!hede).)*$ $ txr -c '@(repeat) @{nothede /~hede/} @(do (put-line nothede)) @(end)' Input $ txr -c '@(repeat) @{nothede /a.*z&~.*hede.*/} @(do (put-line nothede)) @(end)' - az <- echoed az abcz <- echoed abcz abhederz <- not echoed; contains hede ahedez <- not echoed; contains hede ace <- not echoed; does not end in z ahedz <- echoed ahedz /^(?!.*?hede).*$/ var _ = regexGen; var regex = _( _.startOfLine(), _.anything().notContains( // match anything that not contains: _.anything().lazy(), 'hede' // zero or more chars that followed by 'hede', // i.e., anything contains 'hede' ), _.endOfLine() ); Regex Hero is a real-time online Silverlight Regular Expression Tester. XRegex Hero is a real-time online Silverlight Regular Expression Tester. Regex HeroRegex HeroRegex HeroRegex HeroRegex Hero is a real-time online Silverlight Regular Expression Tester. Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her Regex Hero is a real-time online Silverlight Regular Expression Tester. Regex Her is a real-time online Silverlight Regular Expression Tester.Regex Hero egex Hero egex Hero egex Hero egex Hero egex Hero egex Hero Regex Hero is a real-time online Silverlight Regular Expression Tester. RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRegex Hero is a real-time online Silverlight Regular Expression Tester. Regex Her egex Hero egex Hero is a real-time online Silverlight Regular Expression Tester. Regex Her is a real-time online Silverlight Regular Expression Tester. Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her is a real-time online Silverlight Regular Expression Tester. Nobody is a real-time online Silverlight Regular Expression Tester. Regex Her o egex Hero Regex Hero Reg ex Hero is a real-time online Silverlight Regular Expression Tester. 01: ^((?!Regex Hero).)*$ 3.914 // Accepted Answer 02: ^(?:(?!Regex Hero).)*$ 5.034 // With Non-Capturing group 03: ^(?>[^R]+|R(?!egex Hero))*$ 6.137 // Lookahead only on the right first letter 04: ^(?>(?:.*?Regex Hero)?)^.*$ 7.426 // Match the word and check if you're still at linestart 05: ^(?(?=.*?Regex Hero)(?#fail)|.*)$ 7.371 // Logic Branch: Find Regex Hero? match nothing, else anything P1: ^(?(?=.*?Regex Hero)(*FAIL)|(*ACCEPT)) ????? // Logic Branch in Perl - Quick FAIL P2: .*?Regex Hero(*COMMIT)(*FAIL)|(*ACCEPT) ????? // Direct COMMIT & FAIL in Perl ^hede$(*SKIP)(*F)|^.*$ ^hede$(*SKIP)(*F) ^.*$ ^hede$(*SKIP)(*F) ^.*$ In [5]: import vcsn c = vcsn.context('lal_char(a-z), b') c Out[5]: {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z} → Aforementioned (?:(?!hede).)* is great because it can be anchored. ^(?:(?!hede).)*$ # A line without hede foo(?:(?!hede).)*bar # foo followed by bar, without hede between them ^(?!.*hede) # A line without hede ^(?!.*hede)(?=.*foo)(?=.*bar) # A line with foo and bar, but without hede ^(?!.*hede)(?=.*foo).*bar # Same var contains = /abc/; var excludes =/hede/; if(string.match(contains) && !(string.match(excludes))){ //proceed... grep "<Regex for 'doesn't contain hede'>" input grep "^$[^h]\|h\(h\|eh\|edh$*$[^eh]\|e[^dh]\|ed[^eh]$\)*$\|h\(h\|eh\|edh$*$\|e\|ed$\)$" input egrep "^([^h]|h(h|eh|edh)*([^eh]|e[^dh]|ed[^eh]))*(|h(h|eh|edh)*(|e|ed))$" input #!/bin/bash REGEX="^$[^h]\|h\(h\|eh\|edh$*$[^eh]\|e[^dh]\|ed[^eh]$\)*$\|h\(h\|eh\|edh$*$\|e\|ed$\)$" # First four lines as in OP's testcase. cat > testinput.txt <<EOF hoho hihi haha hede h he ah head ahead ahed aheda ahede hhede hehede hedhede hehehehehehedehehe hedecidedthat EOF diff -s -u <(grep -v hede testinput.txt) <(grep "$REGEX" testinput.txt) Files /dev/fd/63 and /dev/fd/62 are identical grep -P '^((?!hede).)*$' input ^([^h]|h(h|e(h|dh))*([^eh]|e([^dh]|d[^eh])))*(h(h|e(h|dh))*(ed?)?)?$ <?PHP function removePrepositions($text){ $propositions=array('/\bfor\b/i','/\bthe\b/i'); if( count($propositions) > 0 ) { foreach($propositions as $exceptionPhrase) { $text = preg_replace($exceptionPhrase, '', trim($text)); } $retval = trim($text); } return $retval; } ?> (?~abc) matches: "", "ab", "aab", "cccc", etc. It doesn't match: "abc", "aabc", "ccccabc", etc. 2.4.1 :016 > ["hoho", "hihi", "haha", "hede"].select{|s| /^(?~hede)$/.match(s)} => ["hoho", "hihi", "haha"] /.*hede(*COMMIT)^|/ s = 'barfoobaz' s.scan(/<span(?:(?!bad).)*?>/) # => ["", ""] ^(?!.*hede) ^(?!.*(hede|hodo|hada)) /^(?!.*hede)/m # JavaScript syntax (?m)^(?!.*hede) # Inline flag ^(?!.*\bhede\b)(?=.*\bhaha\b) ^(?!(?=.*\bhede\b)).*$ ^(?=.*?tasty-treats)((?!chocolate).)*$