如何在字符串中获得可能重叠的匹配

Question

我正在寻找一种方法，无论是在 Ruby 还是 Javascript 中，它都会在一个字符串中针对正则表达式提供所有匹配项，可能是重叠的。

---

假设我有str = "abcadc"，我想找到a 后跟任意数量的字符，然后是c。我正在寻找的结果是["abc", "adc", "abcadc"]。关于如何实现这一点的任何想法？

str.scan(/a.*c/) 会给我["abcadc"]，str.scan(/(?=(a.*c))/).flatten 会给我["abcadc", "adc"]。

Answer 1

def matching_substrings(string, regex)
  string.size.times.each_with_object([]) do |start_index, maching_substrings|
    start_index.upto(string.size.pred) do |end_index|
      substring = string[start_index..end_index]
      maching_substrings.push(substring) if substring =~ /^#{regex}$/
    end
  end
end

matching_substrings('abcadc', /a.*c/) # => ["abc", "abcadc", "adc"]
matching_substrings('foobarfoo', /(\w+).*\1/) 
  # => ["foobarf",
  #     "foobarfo",
  #     "foobarfoo",
  #     "oo",
  #     "oobarfo",
  #     "oobarfoo",
  #     "obarfo",
  #     "obarfoo",
  #     "oo"]
matching_substrings('why is this downvoted?', /why.*/)
  # => ["why",
  #     "why ",
  #     "why i",
  #     "why is",
  #     "why is ",
  #     "why is t",
  #     "why is th",
  #     "why is thi",
  #     "why is this",
  #     "why is this ",
  #     "why is this d",
  #     "why is this do",
  #     "why is this dow",
  #     "why is this down",
  #     "why is this downv",
  #     "why is this downvo",
  #     "why is this downvot",
  #     "why is this downvote",
  #     "why is this downvoted",
  #     "why is this downvoted?"]

Answer 2

在 Ruby 中，您可以使用以下方法实现预期结果：

str = "abcadc"
[/(a[^c]*c)/, /(a.*c)/].flat_map{ |pattern| str.scan(pattern) }.reduce(:+)
# => ["abc", "adc", "abcadc"]

这种方式是否适合您在很大程度上取决于您真正想要实现的目标。

我试图把它放在一个表达式中，但我无法让它工作。我真的很想知道是否有一些科学原因无法通过正则表达式解析，或者我对 Ruby 的解析器 Oniguruma 的了解不够。

Answer 3

您想要所有可能的匹配项，包括重叠的匹配项。正如您所指出的，“How to find overlapping matches with a regexp?”中的前瞻技巧不适用于您的情况。

在一般情况下，我能想到的唯一可行的方法是生成字符串的所有可能子字符串，并根据正则表达式的锚定版本检查每个子字符串。这是蛮力，但它有效。

鲁比：

def all_matches(str, regex)
  (n = str.length).times.reduce([]) do |subs, i|
     subs += [*i..n].map { |j| str[i,j-i] }
  end.uniq.grep /^#{regex}$/
end

all_matches("abcadc", /a.*c/) 
#=> ["abc", "abcadc", "adc"]

Javascript：

function allMatches(str, regex) {
  var i, j, len = str.length, subs={};
  var anchored = new RegExp('^' + regex.source + '$');
  for (i=0; i<len; ++i) {
    for (j=i; j<=len; ++j) {
       subs[str.slice(i,j)] = true;
    }
  }
  return Object.keys(subs).filter(function(s) { return s.match(anchored); });
}

Answer 4

在 JS 中：

function extract_ov_matches(r, s) {
  var res = [], cur;
  r = RegExp('^(?:' + r.source + ')$', r.toString().replace(/^[\s\S]*\/(\w*)$/, '$1').replace('g',''));
  for (var q = 0; q < s.length; ++q)
    for (var w = q; w <= s.length; ++w)
      if (r.test(cur = s.substring(q, w)))
        res.push(cur);
  return res;
}
document.body.innerHTML += "<pre>" + JSON.stringify(extract_ov_matches( /a.*c/g, 'abcadc' ), 0, 4) + "</pre>";

这里的重点是您需要创建输入字符串的所有可能排列，然后返回完全匹配的那些提供的模式。

extract_ov_matches 函数概述

• r 是提供的正则表达式（已编译的正则表达式对象，带有标志）
• s 是输入字符串
• RegExp('^(?:' + r.source + ')$', r.toString().replace(/^[\s\S]*\/(\w*)$/, '$1').replace('g','')); 重新创建带有锚点的正则表达式（^ 用于字符串的开头，$ 用于字符串的结尾）以匹配整个字符串并删除g 标志（因为正则表达式将为used with RegExp#test）
• for (var q = 0; q < s.length; ++q) for (var w = q; w <= s.length; ++w) 用于创建所有输入字符串排列
• if (r.test(cur = s.substring(q, w))) res.push(cur);：如果当前排列完全匹配模式，则添加到res，最终将返回。

Answer 5

▶ str = "abcadc"
▶ from = str.split(/(?=\p{L})/).map.with_index { |c, i| i if c == 'a' }.compact
▶ to   = str.split(/(?=\p{L})/).map.with_index { |c, i| i if c == 'c' }.compact
▶ from.product(to).select { |f,t| f < t }.map { |f,t| str[f..t] }
#⇒ [
#  [0] "abc",
#  [1] "abcadc",
#  [2] "adc"
# ]

我相信，有一种奇特的方法可以找到字符串中字符的所有索引，但我找不到它:( 有什么想法吗？

在“unicode char 边界”上进行拆分使其可以处理'ábĉ' 或'Üve Østergaard' 等字符串。

对于更通用的解决方案，它接受任何“from”和“to”序列，只需进行一点修改：找到字符串中“from”和“to”的所有索引。

Answer 6

这是一种类似于@ndn 和@Mark 的方法，适用于任何字符串和正则表达式。我已将此作为String 的方法实现，因为那是我想看到的地方。对String#[] 和String#scan 来说不是一个很好的赞美吗？

class String
  def all_matches(regex)
    return [] if empty?
    r = /^#{regex}$/
    1.upto(size).with_object([]) { |i,a|
      a.concat(each_char.each_cons(i).map(&:join).select { |s| s =~ r }) }
  end
end

'abcadc'.all_matches /a.*c/
  # => ["abc", "abcadc", "adc"]
'aaabaaa'.all_matches(/a.*a/)
  #=> ["aa", "aa", "aa", "aa", "aaa", "aba", "aaa", "aaba", "abaa", "aaaba",
  #    "aabaa", "abaaa", "aaabaa", "aabaaa", "aaabaaa"] 

Answer 7

RegExp/(a.c)|(a.*c)/g的做法是匹配"a"字符后跟任意字符后跟"c"； "a.*c" 是匹配 "a" 后跟任意字符后跟前一个字符后跟 "c" 字符；注意RegExp(a.*c) 可能会得到改进。 if 的条件检查输入字符串中的最后一个字符是否为 "c" ，如果是 true ，则将完整的输入字符串推送到 res 结果数组

var str = "abcadc"
, res = str.match(/(a.c)|(a.*c)/g); 
if (str[str.length - 1] === "c") res.push(str);

document.body.textContent = res.join(" ")

Answer 8

这种 JavaScript 方法提供了优于 Wiktor's answer 的优势，通过 lazily 使用 generator function 迭代给定字符串的子字符串，这允许您一次使用单个匹配项来处理非常大的输入使用for...of 循环的字符串，而不是一次生成整个匹配数组，这可能导致内存不足异常，因为字符串的子字符串数量随长度呈二次方增长：

function * substrings (str) {
  for (let length = 1; length <= str.length; length++) {
    for (let i = 0; i <= str.length - length; i++) {
      yield str.slice(i, i + length);
    }
  }
}

function * matchSubstrings (str, re) {
  const subre = new RegExp(`^${re.source}$`, re.flags);
  
  for (const substr of substrings(str)) {
    if (subre.test(substr)) yield substr;
  }
}

for (const match of matchSubstrings('abcabc', /a.*c/)) {
  console.log(match);
}