package matching

Content Hierarchy
  1. Alphabetic
  1. Public
  2. All

Type Members

  1. class Regex extends Serializable

    A regular expression is used to determine whether a string matches a pattern and, if it does, to extract or transform the parts that match.

    A regular expression is used to determine whether a string matches a pattern and, if it does, to extract or transform the parts that match.


    This class delegates to the java.util.regex package of the Java Platform. See the documentation for java.util.regex.Pattern for details about the regular expression syntax for pattern strings.

    An instance of Regex represents a compiled regular expression pattern. Since compilation is expensive, frequently used Regexes should be constructed once, outside of loops and perhaps in a companion object.

    The canonical way to create a Regex is by using the method r, provided implicitly for strings:

    val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r

    Since escapes are not processed in multi-line string literals, using triple quotes avoids having to escape the backslash character, so that "\\d" can be written """\d""".


    To extract the capturing groups when a Regex is matched, use it as an extractor in a pattern match:

    "2004-01-20" match {
      case date(year, month, day) => s"$year was a good year for PLs."

    To check only whether the Regex matches, ignoring any groups, use a sequence wildcard:

    "2004-01-20" match {
      case date(_*) => "It's a date!"

    That works because a Regex extractor produces a sequence of strings. Extracting only the year from a date could also be expressed with a sequence wildcard:

    "2004-01-20" match {
      case date(year, _*) => s"$year was a good year for PLs."

    In a pattern match, Regex normally matches the entire input. However, an unanchored Regex finds the pattern anywhere in the input.

    val embeddedDate = date.unanchored
    "Date: 2004-01-20 17:25:18 GMT (10 years, 28 weeks, 5 days, 17 hours and 51 minutes ago)" match {
      case embeddedDate("2004", "01", "20") => "A Scala is born."
    Find Matches

    To find or replace matches of the pattern, use the various find and replace methods. For each method, there is a version for working with matched strings and another for working with Match objects.

    For example, pattern matching with an unanchored Regex, as in the previous example, can also be accomplished using findFirstMatchIn. The findFirst methods return an Option which is non-empty if a match is found, or None for no match:

    val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15"
    val firstDate = date.findFirstIn(dates).getOrElse("No date found.")
    val firstYear = for (m <- date.findFirstMatchIn(dates)) yield

    To find all matches:

    val allYears = for (m <- date.findAllMatchIn(dates)) yield

    To iterate over the matched strings, use findAllIn, which returns a special iterator that can be queried for the MatchData of the last match:

    val mi = date.findAllIn(dates)
    while (mi.hasNext) {
      val d =
      if ( < 1960) println(s"$d: An oldie but goodie.")

    Note that findAllIn finds matches that don't overlap. (See findAllIn for more examples.)

    val num = """(\d+)""".r
    val all = num.findAllIn("123").toList  // List("123"), not List("123", "23", "3")

    Also, the "current match" of a MatchIterator may be advanced by either hasNext or next. By comparison, the Iterator[Match] returned by findAllMatchIn or findAllIn.matchData produces Match objects that remain valid after the iterator is advanced.

    val ns = num.findAllIn("1 2 3")
    ns.start    // 0
    ns.hasNext  // true
    ns.start    // 2
    val ms = num.findAllMatchIn("1 2 3")
    val m  =
    m.start     // 0
    ms.hasNext  // true
    m.start     // still 0
    Replace Text

    Text replacement can be performed unconditionally or as a function of the current match:

    val redacted    = date.replaceAllIn(dates, "XXXX-XX-XX")
    val yearsOnly   = date.replaceAllIn(dates, m =>
    val months      = (0 to 11).map { i => val c = Calendar.getInstance; c.set(2014, i, 1); f"$c%tb" }
    val reformatted = date.replaceAllIn(dates, _ match { case date(y,m,d) => f"${months(m.toInt - 1)} $d, $y" })

    Pattern matching the Match against the Regex that created it does not reapply the Regex. In the expression for reformatted, each date match is computed once. But it is possible to apply a Regex to a Match resulting from a different pattern:

    val docSpree = """2011(?:-\d{2}){2}""".r
    val docView  = date.replaceAllIn(dates, _ match {
      case docSpree() => "Historic doc spree!"
      case _          => "Something else happened"

    1.1, 29/01/2008

    See also


  2. trait UnanchoredRegex extends Regex

    A Regex that finds the first match when used in a pattern match.

    A Regex that finds the first match when used in a pattern match.

    See also


Value Members

  1. object Regex extends Serializable

    This object defines inner classes that describe regex matches and helper objects.