Ruby - 匹配括号的正则表达式？

Question

我试图确定一个字符串是否有正确的右括号。

为此，我使用以下三个括号对。

[]
()
{}

只要格式正确，括号也可以嵌套。

)([]{} - Does not have properly closed brackets because )( is reverse order

[()] - Does contain properly closed brackets.

我尝试过使用正则表达式，经过一番摸索，我明白了。

[^\(\[]*(\(.*\))[^\)\]]*

但是，这样做存在一些问题。

只匹配括号，不匹配括号

我不明白为什么它不匹配括号。

在我的示例中，我清楚地在括号前使用了反斜杠。

输入

[] - true
[()] - true (nested brackets but they match properly)
{} - true
}{ - false (brackets are wrong direction)
}[]} - false (brackets are wrong direction)
[[]] - true (nested brackets but they match properly

Answer 1

non_delimiters = /[^(){}\[\]]*/
Paired = /\(#{non_delimiters}\)|\{#{non_delimiters}\}|\[#{non_delimiters}\]/
Delimiter = /[(){}\[\]]/

def balanced? s
  s = s.dup
  s.gsub!(Paired, "".freeze) while s =~ Paired
  s !~ Delimiter
end

balanced?(")([]{}")
# => false
balanced?("[]")
# => true
balanced?("[()]")
# => true
balanced?("{}")
# => true
balanced?("}{")
# => false
balanced?("}[]}")
# => false
balanced?("[[]]")
# => true

Answer 2

这对于正则表达式来说可能是一个糟糕的用例，我会使用一个简单的堆栈解析器。

def matching_brackets?(a_string)
  brackets =  {'[' => ']', '{' => '}', '(' => ')'}
  lefts = brackets.keys
  rights = brackets.values
  stack = []
  a_string.each_char do |c|
    if lefts.include? c
      stack.push c
    elsif rights.include? c
      return false if stack.empty?
      return false unless brackets[stack.pop].eql? c
    end
  end
  stack.empty?
end

matching_brackets? "[]"
matching_brackets? "[()]"
matching_brackets? "{}"
matching_brackets? "}{"
matching_brackets? "}[]}"
matching_brackets? "[[]]"
matching_brackets? "[[{]}]"

编辑：Cary Swoveland - 编写实际代码并让人们批评它:-?。

更新：有一个讨厌的小错误，我检查结束字符是否与开始字符匹配。修好了！

Answer 3

根据this article，Ruby 2.0 版支持递归正则表达式。这意味着您可以使用特定于 Ruby 的令牌 \g<0> 在您的正则表达式的任何点递归匹配整个正则表达式。这种方法可以有效地模拟堆栈以解决您的任务。

这是生成的正则表达式： [^(){}\[\]]*(\((\g<0>)?\)|\{(\g<0>)?\}|\[(\g<0>)?\])?[^(){}\[\]]*

此更新版本处理如下情况：[(){}]，当多个括号组处于同一级别时。感谢@Jonny 5 指出这个案例：

 [^(){}\[\]]*((\((\g<0>)?\)|\{(\g<0>)?\}|\[(\g<0>)?\])?[^(){}\[\]]*)*

这个表达式需要检查整个输入字符串是否匹配。部分匹配意味着在字符串的某个点的括号排序存在错误。

这是不需要检查整个输入字符串是否匹配的其他版本：

 \A([^(){}\[\]]*((\((\g<1>)?\)|\{(\g<1>)?\}|\[(\g<1>)?\])?[^(){}\[\]]*)*)\Z

您可能会注意到它尝试匹配相应的括号对，然后递归匹配自身。我已经尝试过here，它似乎有效。我不是 Ruby 工程师，所以我无法运行实际的 Ruby 测试，但希望没有必要。

Answer 4

我假设您的字符串仅包含字符串"()[]{}" 中的字符。请注意，对于字符串str 来满足匹配要求：

• str 必须为空或包含子字符串"()"、"[]" 或"[]"；和
• 如果str 不为空，则str 与"()"、"[]" 和"[]" 删除满足匹配要求。

因此，我们可以顺序删除子字符串对，直到我们不能再这样做为止。如果剩下的为空，则原始字符串满足匹配要求；否则它不会：

def matching?(str)
  return true if str.empty?
  s = str.gsub(/\(\)|\[\]|\{\}/,"")
  return false if s == str
  matching?(s)
end

matching?(")([]{}")         #=> false
matching?("[()]")           #=> true
matching?("[()[{()}]{()}]") #=> true 

Answer 5

regex 并不意味着验证字符串中的正确语法，因此非常不适合这种情况。正则表达式是一种在文本中查找模式的工具。

你应该使用解析器。

这是用于执行此操作的堆栈解析器的 ruby​​ 代码：

def validBrackets?(str)
  stack = []
  str.each_char do |char|
    case char
    when '{', '[', '('
      stack.push(char)
    when '}'
      x = stack.pop
      return false if x != '{'
    when ']'
      x = stack.pop
      return false if x != '['
    when ')'
      x = stack.pop
      return false if x != '('
    end
  end
  stack.empty?
end

Answer 6

编辑：根据 Jonny 5 的建议移至顶部
在阅读了下面的 cmets 并受到 Aivean 解决方案的启发后，这是一个修改后的模式
(\[([^][)({}]|\g<0>)*\])|\(\g<2>*\)|\{\g<2>*\}

如果您的正则表达式引擎支持递归，我建议使用 3 种不同的模式作为过滤器，如果您的输入通过了所有这三种模式，那就是很好的匹配

([(?:[^][]|(?R))]) # match nested [] 
(((?:[^)(]|(?R)))) # match nested ()
({(?:[^{}]|(?R))*}) # match nested {}

Answer 7

好吧，我想通了。

def valid_string?(brace)
  stack = []
  brackets = { '{' => '}', '[' => ']', '(' => ')' }
  brace.each_char do |char|
    stack << char if brackets.key?(char)
    return false if brackets.key(char) && brackets.key(char) != stack.pop
  end
  stack.empty?
end

Answer 8

我不明白你怎么能期望你的正则表达式匹配括号。这是您的正则表达式的作用：

[^\(\[]*  # Match any number of characters except ( or [
(         # Start capturing group:
 \(       # Match ( 
 .*       # Match any number of characters (except linebreaks)
 \)       # Match )
)         # End of capturing group
[^\)\]]*  # Match any number of characters except ) or ]