Question

我有下面的代码和奇怪的事情，所以我 println 的东西。当我传递给匹配正则表达式的方法 String 时 - 打印：

---------->1
---------->2

这怎么可能？如何归还不同的回报？

def getInfo(String nameOfFile) {
    def matcher = nameOfFile =~ /(\w+)_(\w+)_(\w+)/
    if (matcher.matches()) {
        matcher.each { fullName, CN, FN, PN->
            println "---------->1"
            return [nameOfFile, CN, FN, PN]
        }
    }
    println "----------->2"
        return [nameOfFile]
}

Answer 1

这只是从Closure返回，而不是封闭方法

        return [nameOfFile, CN, FN, PN]

根据您尝试做的事情（您不提供任何示例输入），您可能需要findResult而不是each：

def getInfo( String nameOfFile ) {
    def matcher = nameOfFile =~ /(\w+)_(\w+)_(\w+)/
    if (matcher.matches()) {
        matcher.findResult { fullName, CN, FN, PN->
            [nameOfFile, CN, FN, PN]
        }
    }
    else {
        [nameOfFile]
    }
}

Answer 2

以下是Java中Groovy代码的非常粗略的近似值（使用1.6）：

import java.util.*;
import java.util.regex.*;

interface ClosureBlock {
    Object each(String... args);
}

public class Runner {    
    public List<String> getInfo(String nameOfFile) {
        List<String> results = new ArrayList<String>();

        Pattern regex = Pattern.compile("(\\w+)_(\\w+)_(\\w+)");
        Matcher matcher = regex.matcher(nameOfFile);

        if (matcher.matches()) {
            String fullName = matcher.group(0);
            String CN = matcher.group(1);
            String FN = matcher.group(2);
            String PN = matcher.group(3);

            ClosureBlock closure = new ClosureBlock() {
                public Object each(String... args) {
                    List<String> results = new ArrayList<String>();
                    String fullName = args[0];
                    String CN = args[1];
                    String FN = args[2];
                    String PN = args[3];

                    results.add(fullName);
                    results.add(CN);
                    results.add(FN);
                    results.add(PN);

                    // this return does not exit getInfo()
                    System.out.println("----------->1");
                    return results;
                }                
            };

            // each returns an Object but we didn't assign it
            closure.each(fullName, CN, FN, PN);
        }

        System.out.println("----------->2");
        results.add(nameOfFile);
        return results;
    }   

    public static void main(String... args) {
        Runner quick = new Runner();
        List<String> list = quick.getInfo(args[0]);
        System.out.println(list);
    }
}

关键点是：

Runner使用每个方法定义一个匿名内部类。在each方法中调用return不会退出getInfo方法
即使each方法返回Object，我们也不会将其分配给任何内容，以便List<String>中的getInfo不受影响。

Java丑陋复杂。 Groovy代码更优雅，但是关于你的问题，Java代码说明了这个想法。

如何在Groovy中破解方法的执行？

2 个答案: