Extracting values using Regular Expressions

Table of contents

Reading Time: 2 minutes

Regular expression is a sequence of characters that define a search pattern. Regular expressions are used to find particular sequences in a string or is used to extract value from a string.

Fields of application range from validation to parsing/replacing strings, passing through translating data to other formats and web scraping.

To define a search pattern in scala, we need to import scala.util.matching.Regex and to convert a string into a regular expression, use .r method.

scala> import scala.util.matching.Regex
import scala.util.matching.Regex

scala> val pattern = "[a-zA-Z]+".r
pattern: scala.util.matching.Regex = [a-zA-Z]+

scala> val inputString = "{'tiger', 'cat'}"
inputString: String = {'tiger', 'cat'}

scala> pattern.findFirstMatchIn(inputString)
res0: Option[scala.util.matching.Regex.Match] = Some(tiger)

In the above example, we have pattern as the regex variable. The regex defined for this variable matches the word that contains only alphabets. findFirstMatchIn() method is defined in scala.util.matching.Regex to find the first occurrence of the pattern in the input string. Also, the return type of findFirstMatchIn() is an optional value. Similarly, we have findAllMatchIn that returns an iterator to iterate through all the possible matches found in the input string. In the below example, foundPatterns is an iterator and we have converted it to an array to see all the possible options.

scala> val foundPatterns = pattern.findAllMatchIn(inputString)
foundPatterns: Iterator[scala.util.matching.Regex.Match] = non-empty iterator

scala> foundPatterns.toArray
res2: Array[scala.util.matching.Regex.Match] = Array(tiger, cat)

Regular expressions are also widely used to extract values from a string. For example, to count the number of words in a file, we usually first remove all the extra spaces and then split the words on the basis of commas and dots. To make the process easy, we can use regular expression. To split the words of a file, we can write the regex as shown below:

scala> val regex = "\\b\\w+?\\b".r
regex: scala.util.matching.Regex = \b\w+?\b

scala> val inputString = s"Do not make excuses, \t make improvements."
inputString: String = Do not make excuses, make improvements.

scala> val words = regex.findAllMatchIn(inputString)
words: Iterator[scala.util.matching.Regex.Match] = non-empty iterator

scala> val words = regex.findAllMatchIn(inputString).toArray
words: Array[scala.util.matching.Regex.Match] = Array(Do, not, make, excuses, make, improvements)

There are many other use cases of regular expressions. It also works as an extractor. The regex for the values that need to be extracted must be wrapped inside the parenthesis. For example, to extract the id and name of a student from the input string “Student(1, Aashrita)”, we can use regular expression as shown below:

scala> val student = "Student(1, Aashrita)"
student: String = Student(1, Aashrita)

scala> val studentRegex = "Student\\((\\d+),(.*)\\)".r
studentRegex: scala.util.matching.Regex = Student\((\d+),(.*)\)

scala> student match {
| case studentRegex(id, name) => s"Found student with id: $id and name: $name."
| case _ => "Student not found."
| }
res0: String = Found student with id: 1 and name: Aashrita.

I hope this helps you to get a better understanding of how regular expression works. For more information, please have a look at the references below and refer the regex cheat sheet to write a regular expression for a particular use case.

References