Regular Expression 1 : Basics and findAllIn

This is the first of a series on Regular expression use in Scala. There was a previous post related that is also worth looking at but the same tips will be revisited in this series: Matching Regular Expressions.

Perhaps the most important thing for regular expressions in Scala is to be aware of the raw string syntax:

1. /* 
2. normal strings treat the \ character as the escape character 
3. so this fails
4. */
5. scala> val normalString = "\.+((xyz)|(abc))"
6. < console>:1: error: invalid escape character
7.        val normalString = "\.+((xyz)|(abc))"
8.                             ^
10. /*
11. raw strings a great for regular expressions so you don't have 
12. escape \ characters
13. */
14. scala> val rawString = """\.+((xyz)|(abc))"""
15. rawString: java.lang.String = \.+((xyz)|(abc))

The next thing is to realize that one can easily create a Regex object from any string with the r method:

1. scala> val regex = """\.+((xyz)|(abc))""".r
2. regex: scala.util.matching.Regex = \.+((xyz)|(abc))

A regex has the standard matching methods one might expect but lets look at findAllIn and the associated MatchData for now. findAllIn returns a MatchIterator which is an Iterator[String] with MatchData. When iterating over the MatchIterator the full matched string will be returned, if you need the subgroups you will need to convert the MatchIterator to an Iterator[Match].

1. // findAllIn returns an iterator over the matches.  
2. scala> "l|he".r findAllIn "hello xyz" foreach {println _}
3. he
4. l
5. l
7. // Each match can have multiple groups
8. // Note: Each element in MatchIterator are strings (no Match objects)
9. scala> ("(h)(e)|(l)".r findAllIn "hello xyz").matchData foreach { m => println(m.matched mkString ",")}   
10. h,e
11. l
12. l
14. // to access subgroups use the matchData method
15. // Note: there are 3 subgroups in the regex
16. scala> ("(h)(e)|(l)".r findAllIn "hello xyz").matchData foreach { m => println( m.subgroups mkString ",")}
17. h,e,null
18. null,null,l
19. null,null,l
21. /*
22. if matched is called the full match is returned (as if you did not convert the iterator to an Iterator[Match])
23. /*
24. scala> ("(h)(e)|(l)".r findAllIn "hello xyz").matchData foreach { m => println(m.matched)}
25. he
26. l
27. l
29. /*
30. The following demonstrates more of the methods on Match
31. Essentially the elements are:
32. (start index of match, end index of match, string before match, string after match, string the match was performed on)
33. */
34. scala> ("(h)(e)|(l)".r findAllIn "hello xyz").matchData foreach { m => println(m.start, m.end, m.before, m.after, m.source)}
35. (0,2,,llo xyz,hello xyz)
36. (2,3,he,lo xyz,hello xyz)
37. (3,4,hel,o xyz,hello xyz)

The last methods to look at for this topic are findFirstIn, findFirstMatchIn and the Regex constructor:

1. /*
2. Groups names can be assigned if the Regex constructor is used
3. */
4. scala> val withNames = new util.matching.Regex("(h)(e)|(l)", "h", "e", "l")
5. withNames: scala.util.matching.Regex = (h)(e)|(l)
7. scala> withNames findFirstIn "hello xyz"
8. res28: Option[String] = Some(he)
10. /*
11. I know a match will be found so I am extracting the value from the Option by assigning it to Some(he)
12. */
13. scala> val Some(he) = withNames findFirstMatchIn "hello xyz"  
14. he: scala.util.matching.Regex.Match = he
16. scala> he.groupNames
17. res29: Seq[String] = Array(h, e, l)
19. scala> he.group("h")
20. res30: String = h
22. scala> he.group("e") 
23. res31: String = e
25. scala> he.group(1)
26. res32: String = h
28. scala> he.group(2)
29. res33: String = e
31. // Uh oh. NullPointer warning!
32. scala> he.group(3)
33. res34: String = null
35. scala> he.groupCount
36. res35: Int = 3