具有基于匹配的回调的正则表达式

Question

我有一个函数，该函数接受输入字符串，然后通过几个正则表达式运行该字符串，直到找到匹配项。 找到匹配项后，我将返回原始字符串和匹配项的函数的输出。 因此在红宝石中：

str = "my very long original string ... millions of characters"
case str
  when regex1
    do_something1(str,$1)
  when regex2
    do_something2(str,$1)
  when regex3
    do_something3(str,$1)
  ...
  when regex100000
    do_something100000(str,$1)
  else
    do_something_else(str)
end

现在，Ruby是否真的在优化此切换循环，以使str仅被遍历一次？ 假设不是，那么使用嵌入了回调的一个大的长正则表达式可以更有效地执行此功能。 像这样：

/(?<callback:do_something1>regex1)|
(?<callback:do_something2>regex2)|
(?<callback:do_something3>regex3)|
   ...
(?<callback:do_something100000>regex100000)/

有什么技术可以做到这一点？

Answer 1

如果是Ruby 1.9，并且在正则表达式中使用命名组，则可以将所有正则表达式合并为一个，但有些麻烦。 这是完成繁重工作的课程：

class BigPatternMatcher

  def initialize(patterns_and_functions, no_match_function)
    @regex = make_big_regex(patterns_and_functions)
    @no_match_function = no_match_function
  end

  def match(s, context)
    match = @regex.match(s)
    context.send(function_name(match), match)
  end

  private

  FUNC_GROUP_PREFIX = "func_"
  FUNC_GROUP_REGEX = /^#{FUNC_GROUP_PREFIX}(.*)$/

  def function_name(match)
    if match
      match.names.grep(FUNC_GROUP_REGEX).find do |name|
        match[name]
      end[FUNC_GROUP_REGEX, 1]
    else
      @no_match_function
    end
  end

  def make_big_regex(patterns_and_functions)
    patterns = patterns_and_functions.map do |pattern, function|
      /(?<#{FUNC_GROUP_PREFIX}#{function}>#{pattern.source})/
    end
    Regexp.union(patterns)
  end

end

我们将回到工作原理。 要使用它，您需要一个正则表达式列表以及应该为每个表达式调用的函数的名称。 确保仅使用命名组：

PATTERNS_AND_FUNCTIONS = [
  [/ABC(?<value>\d+)/, :foo],
  [/DEF(?<value>\d+)/, :bar],
]

这些函数，包括没有匹配项时被调用的函数：

def foo(match)
  p ["foo", match[:value]]
end

def bar(match)
  p ["bar", match[:value]]
end

def default(match)
  p ["default"]
end

最后，这是使用方法。 BigPatternMatcher#match将字符串与要调用的对象进行匹配：

matcher = BigPatternMatcher.new(PATTERNS_AND_FUNCTIONS, :default)
matcher.match('blah ABC1 blah', self)    # => ["foo", "1"
matcher.match('blah DEF2 blah', self)    # => ["bar", "2"]
matcher.match('blah blah', self)         # => ["default"]

请参见下面的折痕，了解使之起作用的技巧。

---

BigPatternMatcher#make_big_regex将所有正则表达式组合为一个，每个正则表达式用括号括起来并用|分隔| ，例如

/(ABC(?<value>\\d+))|(DEF(?<value>\\d+))/

但是，这还不够。 当子表达式之一匹配时，我们需要某种方式来标识哪个子表达式匹配，从而确定要调用的函数。 为此，我们将使每个子表达式都有自己的命名组，其名称基于应调用的函数：

/(?<func_foo>ABC(?<value>\\d+))|(?<func_bar>DEF(?<value>\\d+))/

现在，让我们看看如何从匹配到调用函数。 给定字符串：

"blah ABC1 blah"

那么匹配组是：

#<MatchData "ABC1" func_foo:"ABC1" value:"1" func_bar:nil value:nil>

要找出要调用的函数，我们只需要找到名称以“ func_”开头且值为非nil的匹配项即可。 组名称中“ func_”之后的部分为要调用的函数命名。

---

针对您的问题，使用简单的技术来衡量其性能是读者的一项练习。