Date Parser

Regular Expressions

Regular expressions (regex) are a powerful tool for working with strings in Elixir. Regular expressions in Elixir follow the PCRE specification (Perl Compatible Regular Expressions). String patterns representing the regular expression's meaning are first compiled then used for matching all or part of a string.

In Elixir, the most common way to create regular expressions is using the ~r sigil. Sigils provide syntactic sugar shortcuts for common tasks in Elixir. To match a string literal, we can use the string itself as a pattern following the sigil.

~r/test/

The =~/2 operator is useful to perform a regex match on a string to return a boolean result.

"this is a test" =~ ~r/test/
# => true

Two notes about using sigils:

• many different delimiters may be used depending on your requirements rather than /
• string patterns are already escaped, when writing the pattern as a string not using a regex, you will have to escape backslashes (\)

Character classes

Matching a range of characters using square brackets [] defines a character class. This will match any one character to the characters in the class. You can also specify a range of characters like a-z, as long as the start and end represent a contiguous range of code points.

regex = ~r/[a-z][ADKZ][0-9][!?]/
"jZ5!" =~ regex
# => true
"jB5?" =~ regex
# => false

Shorthand character classes make the pattern more concise. For example:

• \d short for [0-9] (any digit)
• \w short for [A-Za-z0-9_] (any 'word' character)
• \s short for [ \t\r\n\f] (any whitespace character)

When a shorthand character class is used outside of a sigil, it must be escaped: "\\d"

Alternations

Alternations use | as a special character to denote matching one or another

regex = ~r/cat|bat/
"bat" =~ regex
# => true
"cat" =~ regex
# => true

Quantifiers

Quantifiers allow for a repeating pattern in the regex. They affect the group preceding the quantifier.

• {N, M} where N is the minimum number of repetitions, and M is the maximum
• {N,} match N or more repetitions
  • {0,} may also be written as *: match zero-or-more repetitions
  • {1,} may also be written as +: match one-or-more repetitions
• {,N} match up to N repetitions

Groups

Round brackets () are used to denote groups and captures. The group may also be captured in some instances to be returned for use. In Elixir, these may be named or un-named. Captures are named by appending ?<name> after the opening parenthesis. Groups function as a single unit, like when followed by quantifiers.

regex = ~r/(h)at/
Regex.replace(regex, "hat", "\\1op")
# => "hop"

regex = ~r/(?<letter_b>b)/
Regex.scan(regex, "blueberry", capture: :all_names)
# => [["b"], ["b"]]

Anchors

Anchors are used to tie the regular expression to the beginning or end of the string to be matched:

• ^ anchors to the beginning of the string
• $ anchors to the end of the string

Interpolation

Because the ~r is a shortcut for "pattern" |> Regex.escape() |> Regex.compile!(), you may also use string interpolation to dynamically build a regular expression pattern:

anchor = "$"
regex = ~r/end of the line#{anchor}/
"end of the line?" =~ regex
# => false
"end of the line" =~ regex
# => true