groovy - 如何找到内部嵌套的内容？

Question

假设我有一个这样的字符串：

string = [+++[>>[--]]]abced

现在我想以某种方式返回一个包含：[[--],[>>],[+++]]. 那是最深[嵌套的内容，其次是其他嵌套。我想出了这样的解决方案：

def string = "[+++[>>[--]]]"
loop = []
temp = []
string.each {
    bool = false
    if(it == "["){
        temp = []
        bool = true
    }
    else if( it != "]")
        temp << it 
    if(bool)
         loop << temp

}
println loop.reverse()

但这确实需要abced最后一个字符串]并放入结果中！。但我想要的只是[[--],[>>],[+++]]

有什么绝妙的方法可以解决这个问题吗？

Answer 1

如果您不介意使用递归，您可以使用它

def sub(s , list){
    if(!s.contains('[') && !s.contains('[')) 
        return list
    def clipped = s.substring(s.lastIndexOf('[')+1, s.indexOf(']'))
    list.add(clipped)
    s = s - "[$clipped]"
    sub(s , list)
}

打电话

sub('''[+++[>>[--]]]abced''' , [])

返回包含在大括号之间的所有子部分的列表。

['--', '>>', '+++']

Answer 2

如果你的括号是对称的，你可以只引入一个计数器变量来保存括号嵌套的深度。输出中只允许高于 0 的深度级别：

def string = "[+++[>>[--]]]abc"
loop = []
temp = []
depth = 0;
string.each {
  bool = false
  if(it == "["){
    temp = []
    bool = true
    depth++;
  }   
  else if (it == "]"){
    depth--;
  }   
  else if (depth > 0){ 
    temp << it  
  }   
  if(bool){
    loop << temp
  }   
}
println loop.reverse()

Answer 3

class Main {

    private static final def pattern = ~/([^\[]*)\[(.+?)\][^\]]*/

    static void main(String[] args) {
        def string = "[+++[>>[--]]]abced"

        def result = match(string)
        println result

    }

    static def match(String val) {
        def matcher = pattern.matcher(val);

        if (matcher.matches()) {
            return matcher.group(1) ? match(matcher.group(2)) + matcher.group(1) : match(matcher.group(2))
        }
        [val]
    }
}

System.out

[--, >>, +++]

正则表达式模式中第一组的捕获可能会得到改进。现在第一组是任何不是的字符，[如果第一组前面没有任何字符，[那么第一组将包含一个空字符串。