groovy-正则表达式

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

4	def pattern = ~/foo/

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

8

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/)

14

15	// ==~ tests, if String matches the pattern

16	assert "2009" ==~ /\d+/ // returns TRUE

17	assert "holla" ==~ /\d+/ // returns FALSE

18

19	// lets create a Matcher

20	def matcher = "cheesecheese" =~ /cheese/

21	assert matcher instanceof Matcher

22

23	// lets do some replacement

24	def cheese = ("cheesecheese" =~ /cheese/).replaceFirst("nice")

25	assert cheese == "nicecheese"

26	assert "color" == "colour".replaceFirst(/ou/, "o")

27

28	cheese = ("cheesecheese" =~ /cheese/).replaceAll("nice")

29	assert cheese == "nicenice"

30

31	// simple group demo

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"

42

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:

45

46	matcher = "eat green cheese" =~ "e+"

47

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]

52

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 }

62	matcher.reset()

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.

68

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

匹配每行开头的大写单词：

1	def before='''

2

apple

3

orange

4

y

5

banana

6

'''

7

8	def expected='''

9

Apple

10

Orange

11

Y

12

Banana

13

'''

14

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')