Regex

Some text operations are simple—we can compare a string or test a character. But for complex things, a Regex provides more power and is more effective.

In this language we can create a regular expression from a string (a pattern). We then invoke methods that find matches on that pattern.

FindFirstMatchIn example

Here we create a Regex object from a pattern string with r(). Please note how we specify the Regex pattern—we use 3 quotes, which is a raw string literal.

object Program {
    def main(args: Array[String]): Unit = {
        // Get Regex from this string.
        val test = """\d* pounds""".r

        // A list of strings to match.
        val data = List("20 pounds", "5 pounds", "Error")

        // Loop over strings in the list.
        for (v <- data) {
            // Try to match the strings.
            val result = test.findFirstMatchIn(v)
            if (result.isDefined) {
                println(s"$v = true")
            }
            else {
                println(s"$v = false")
            }
        }
    }
}
20 pounds = true
5 pounds = true
Error = false

Groups

These help us label and access parts of a string. We use parentheses around the parts of our Regex we want to be placed in groups. And we pass group names to the r() method.

object Program {
    def main(args: Array[String]): Unit = {
        // An example string.
        val animals = "cat and dog"

        // Match words surrounding "and" and give them group names.
        val result = """(\w+) and (\w+)""".r("animal1", "animal2").findFirstMatchIn(animals)

        // See if match occurred.
        if (result.isDefined) {
            // Get the Regex.
            val regex = result.get
            // Get named groups and display them.
            val animal1 = regex.group("animal1")
            val animal2 = regex.group("animal2")
            println(animal1)
            println(animal2)
        }
    }
}
cat
dog

FindAllIn

This program uses findAllIn to get a MatchIterator from a Regex. Here we match all substrings in the string that start with a lowercase "a" or "b" and are followed by 2 digits.

object Program {
    def main(args: Array[String]): Unit = {
        // Contains space-separated ID codes.
        val ids = "a_1 a21 a31 b21 b_3 c10"

        // Match all occurrences starting with "a" or "b" and with 2 digits.
        val result = """[ab]\d\d""".r.findAllIn(ids)

        // Iterate over our result.
        // ... This accesses the Regex.MatchIterator.
        for (r <- result) {
            println(r)
        }
    }
}
a21
a31
b21

Scala provides pattern matching for variables with the "match" keyword. But for text, we can use regular expressions. We create them with the r() function.