更新:正如 @Ciantic 在评论中指出的那样，它失败了“在oo之前有两个ff”的匹配。

^(f(o[^o]|[^o])|[^f])*$

注意：在客户端上仅仅否定匹配要容易得多，而不是使用上述正则表达式。

该正则表达式假定每行以换行符结尾，如果不是这样，则请参阅C++和grep的正则表达式。

Perl、Python、C++和grep的示例程序都给出相同的输出。

• Perl： Perl

  #!/usr/bin/perl -wn
  print if /^(f(o[^o]|[^o])|[^f])*$/;
  

• Python (链接：http://ideone.com/3CYA6)

  #!/usr/bin/env python
  import fileinput, re, sys
  from itertools import ifilter
  
  re_not_foo = re.compile(r"^(f(o[^o]|[^o])|[^f])*$")
  for line in ifilter(re_not_foo.match, fileinput.input()):
      sys.stdout.write(line)
  

• C++: C++

  #include <iostream>
  #include <string>
  #include <boost/regex.hpp>
  
  int main()
  {
    boost::regex re("^(f(o([^o]|$)|([^o]|$))|[^f])*$");
    //NOTE: "|$"s are there due to `getline()` strips newline char
  
    std::string line;
    while (std::getline(std::cin, line)) 
      if (boost::regex_match(line, re))
        std::cout << line << std::endl;
  }
  

• grep

  $ grep "^(f(o([^o]|$)|([^o]|$))|[^f])*$" in.txt
  

示例文件：

foo
 foo 
abdfoode
abdfode
abdfde
abcde
f

fo
foo
fooo
ofooa
ofo
ofoo

输出

abdfode
abdfde
abcde
f

fo
ofo

发现了这个问题，并将没有完全工作的正则表达式视为个人挑战。我相信我已经成功地创建了一种正则表达式，它可以对所有输入产生作用-前提是您可以使用原子组/占有量化器。

当然，我不确定是否存在不使用 lookahead 就允许原子分组的 flavor，但问题是在正则表达式中是否可能陈述一个不使用 lookahead 的排除，而这在技术上是可能的：

A(?:$|[^f]++|f++(?:[^o]|$)|(?:f++o)*+(?:[^o]|$))*

解释：

A                         #Start of string
(?:                        #Non-capturing group
    $                      #Consume end-of-line. We re not in foo-mode.
    |[^f]++                #Consume every non- f . We re not in foo-mode.
    |f++(?:[^o]|$)          #Enter foo-mode with an  f . Consume all  f s, but only exit foo-mode if  o  is not the next character. Thus,  f  is valid but  fo  is invalid.
    |(?:f++o)*+(?:[^o]|$)  #Enter foo-mode with an  f . Consume all  f s, followed by a single  o . Repeat, since  (f+o)*  by itself cannot contain  foo . Only exit foo-mode if  o  is not the next character following (f+o). Thus,  fo  is valid but  foo  is invalid.
)*                         #Repeat the non-capturing group
                         #End of string. Note that this regex only works in flavours that can match $

如果由于任何原因，您无法使用占位符量词或回顾，但可以使用原子群组，您可以使用：

A(?:$|(?>[^f]+)|(?>f+)(?:[^o]|$)|(?>(?:(?>f+)o)*)(?:[^o]|$))*

正如其他人指出的那样，不过，通过其他手段来取消比赛可能更实际。

我偶然发现了这个问题，寻找我自己的正则表达式排除解决方案，在这里我试图在正则表达式中排除一个序列。

grep -v foo