Groovy使用~”pattern” 来支持正则表达式，它将使用给定的模式字符串创建一个编译好的Java Pattern 对象。Groovy也支持 =~（创建一个Matcher）和 ==~ (返回boolean，是否给定的字符串匹配这个pattern)操作符。
对于groups的匹配， matcher[index] 是一个匹配到的group字符串的List或者string。
1 |
import java.util.regex.Matcher
|
2 |
import java.util.regex.Pattern
|
3 |
// ~ creates a Pattern from String |
5 |
assert pattern instanceof Pattern
|
6 |
assert pattern.matcher("foo").matches() // returns TRUE
|
7 |
assert pattern.matcher("foobar").matches() // returns FALSE, because matches() must match whole String
|
9 |
// =~ creates a Matcher, and in a boolean context, it's "true" if it has at least one match, "false" otherwise. |
10 |
assert "cheesecheese" =~ "cheese"
|
11 |
assert "cheesecheese" =~ /cheese/
|
12 |
assert "cheese" == /cheese/ /*they are both string syntaxes*/
|
13 |
assert ! ("cheese" =~ /ham/)
|
15 |
// ==~ tests, if String matches the pattern |
16 |
assert "2009" ==~ /\d+/ // returns TRUE
|
17 |
assert "holla" ==~ /\d+/ // returns FALSE
|
19 |
// lets create a Matcher |
20 |
def matcher = "cheesecheese" =~ /cheese/
|
21 |
assert matcher instanceof Matcher
|
23 |
// lets do some replacement |
24 |
def cheese = ("cheesecheese" =~ /cheese/).replaceFirst("nice")
|
25 |
assert cheese == "nicecheese"
|
26 |
assert "color" == "colour".replaceFirst(/ou/, "o")
|
28 |
cheese = ("cheesecheese" =~ /cheese/).replaceAll("nice")
|
29 |
assert cheese == "nicenice"
|
32 |
// You can also match a pattern that includes groups. First create a matcher object, |
33 |
// either using the Java API, or more simply with the =~ operator. Then, you can index |
34 |
// the matcher object to find the matches. matcher[0] returns a List representing the |
35 |
// first match of the regular expression in the string. The first element is the string |
36 |
// that matches the entire regular expression, and the remaining elements are the strings |
37 |
// that match each group. |
38 |
// Here's how it works: |
39 |
def m = "foobarfoo" =~ /o(b.*r)f/
|
40 |
assert m[0] == ["obarf", "bar"]
|
41 |
assert m[0][1] == "bar"
|
43 |
// Although a Matcher isn't a list, it can be indexed like a list. In Groovy 1.6 |
44 |
// this includes using a collection as an index: |
46 |
matcher = "eat green cheese" =~ "e+"
|
48 |
assert "ee" == matcher[2]
|
49 |
assert ["ee", "e"] == matcher[2..3]
|
50 |
assert ["e", "ee"] == matcher[0, 2]
|
51 |
assert ["e", "ee", "ee"] == matcher[0, 1..2]
|
53 |
matcher = "cheese please" =~ /([^e]+)e+/
|
54 |
assert ["se", "s"] == matcher[1]
|
55 |
assert [["se", "s"], [" ple", " pl"]] == matcher[1, 2]
|
56 |
assert [["se", "s"], [" ple", " pl"]] == matcher[1 .. 2]
|
57 |
assert [["chee", "ch"], [" ple", " pl"], ["ase", "as"]] == matcher[0,2..3]
|
58 |
// Matcher defines an iterator() method, so it can be used, for example, |
59 |
// with collect() and each(): |
60 |
matcher = "cheese please" =~ /([^e]+)e+/
|
61 |
matcher.each { println it }
|
63 |
assert matcher.collect { it }?? ==
|
64 |
[["chee", "ch"], ["se", "s"], [" ple", " pl"], ["ase", "as"]]
|
65 |
// The semantics of the iterator were changed by Groovy 1.6. |
66 |
// In 1.5, each iteration would always return a string of the entire match, ignoring groups. |
67 |
// In 1.6, if the regex has any groups, it returns a list of Strings as shown above. |
69 |
// there is also regular expression aware iterator grep() |
70 |
assert ["foo", "moo"] == ["foo", "bar", "moo"].grep(~/.*oo$/)
|
71 |
// which can be written also with findAll() method |
72 |
assert ["foo", "moo"] == ["foo", "bar", "moo"].findAll { it ==~ /.*oo/ }
|
More Examples
匹配每行开头的大写单词：
15 |
assert expected == before.replaceAll(/(?m)^\w+/,
|
16 |
{ it[0].toUpperCase() + ((it.size() > 1) ? it[1..-1] : '') })
|
匹配字符串中的每一个大写单词
1 |
assert "It Is A Beautiful Day!" ==
|
2 |
("it is a beautiful day!".replaceAll(/\w+/,
|
3 |
{ it[0].toUpperCase() + ((it.size() > 1) ? it[1..-1] : '') }))
|
使用 .toLowerCase() 让其他单词小写：
1 |
assert "It Is A Very Beautiful Day!" ==
|
2 |
("it is a VERY beautiful day!".replaceAll(/\w+/,
|
3 |
{ it[0].toUpperCase() + ((it.size() > 1) ? it[1..-1].toLowerCase() :'') }))
|
Gotchas
怎么使用String.replaceAll()的反向引用
GStrings 可能和你期望的不一样
1 |
def replaced = "abc".replaceAll(/(a)(b)(c)/, "$1$3")
|
产生一个类似于下面的错误：
[] illegal string body character after dollar sign:
解决办法：: either escape a literal dollar sign “\$5″ or bracket the value expression “${5}” @ line []
Solution:
Use ‘ or / to delimit the replacement string:
1 |
def replaced = "abc".replaceAll(/(a)(b)(c)/, '$1$3')
|
时间： 2024-09-21 03:40:47
