Ruby RegEx

A Regex (Regular Expression) is a pattern that is used to check whether a given string matches that pattern.

In Ruby, regex patterns are defined between two forward slashes (/pattern/). For example,

# A regex pattern
/^m.t$/       

The above pattern indicates a three-letter string where,

• ^ - Marks the start of a string (here, the string starts with m).
• . - Indicates any one letter or character
• $ - marks the end of a string (here, the string ends with t).

For example strings like "mat" and "mit" match the above regex pattern.

However, strings like "mom" and "magnet" don't match because these strings are not 3 letter words that start with m and end with t.

Ruby Regex Class

Ruby provides the Regex class to work with regular expressions. You can create a regex pattern using either the literal syntax or the Regexp.new method.

Syntax

# Using literal syntax
/pattern/

# Using Regexp.new
Regexp.new("pattern")

Here, pattern is the regular expression pattern you want to match.

Regex Flags in Ruby

Regex flags modify how patterns are interpreted. They are added after the closing slash of the regex.

Some commonly used flags are:

• i - Case-insensitive match
• m - Multiline mode

Let's see an example,

/^m/i

This pattern matches strings that start with "m" or "M".

Example: Ruby Regex

# A regular expression pattern for a five-letter word
# that starts with "a" and ends with "e"
pattern = /^a...e$/

# Test string
word = "apple"

# Check if the word matches the pattern
if word.match?(pattern)
  puts "String matches the pattern"
else
  puts "String doesn't match the pattern"
end

Output

String matches the pattern

In the above example, we have checked whether the string "apple" matches the defined regular expression pattern.

The pattern "^a...e$" indicates any five-letter string starting with a and ending with e.

Here, the match? method returns true if the string that we pass matches the regex pattern.

If we pass another string like "apache", it won't match with pattern because "apache" has more than five characters.

Metacharacters

To specify regular expressions, metacharacters are used. Metacharacters are characters that are interpreted in a special way by a regex engine.

Some basic metacharacters are:

Square Brackets: []

[] specifies a set of characters you wish to match. For example,

/[abc]/

This pattern matches any string that contains any of the given characters: a, b, or c.

Let's check if the following strings match the regex pattern [abc].

Period

A period specifies any single character (except newline '\n'). For example,

/.../

The pattern above matches any three-character substring (except newline).

Let's check if the following strings match the regex pattern ..., which represents a group of three characters.

Caret: ^

The caret symbol ^ specifies that the string starts with a certain character. For example,

/^m/

This pattern matches strings starting with the letter "m".

Let's check if the following strings match the regex pattern ^m.

Dollar: $

The dollar symbol $ specifies that the string ends with a certain character. For example,

/y$/

This pattern matches strings ending with the letter "y"

Let's check if the following strings match the regex pattern y$.

Star: *

The star symbol * matches zero or more occurrences of the preceding element. For example,

/ca*t/

Here, a is the element that precedes *. So, this pattern matches strings that have any number (including zero) of a in between c and t.

Let's check if the following strings match the regex pattern ca*t.

Plus: +

The plus symbol + matches one or more occurrences of the preceding element. For example,

/ma+t/

This pattern matches strings that have one or more occurrences of a in between m and t

Let's check if the following strings match the regex pattern ma+t.

Question Mark: ?

The question mark symbol ? matches zero or one occurrence of the preceding element. For example,

/ma?n/

This pattern matches strings that have one or zero number of a in between m and n.

Let's check if the following strings match the regex pattern ma?n.

Braces: {}

The braces symbol {} is used to specify the range of repetitions of the preceding element.

/a{2}/

This pattern matches strings that have exactly two a characters in a row.

Braces {} can be used as:

# Exactly n times
{n}

# At least n times
{n,}

# Between n and m times
{n, m}

Let's check if the following string examples match the regex pattern /a{2}/.

Alternation: |

The vertical bar | is used as an or operator. For example,

/a|b/

This pattern matches strings that have either a or b.

Let's check if the following strings match the regex pattern a|b.

Parentheses: ()

Parentheses () are used to group sub-patterns in a regular expression.

Grouping allows you to apply quantifiers (like +, *, or {}) to the entire group. For example,

/(ab)+/

This pattern matches one or more occurrences of the substring ab.

Let's check if the following strings match the regex pattern (ab)+.

Special Sequences

Ruby regex also supports special sequences for common character sets.

Example: Matching Digits

The \d sequence matches if the specified characters are one or more digits. For example,

/\d+/

This pattern matches one or more digits.

Let's check if the following string examples match the regex pattern \d+.

Escape Sequences

If you want to match special characters literally (like . or *), you need to escape them with a backslash \. For example,

/\./

This matches a literal period ..

Let's check if the following strings match the regex pattern \..

Regex Methods

Ruby provides several methods to work with regex:

Example: Using Regex Methods

text = "I have 2 cats and 3 dogs"

# Find first match
# Output: 7
puts text =~ /\d/

# Get all digits
# Output: 2, 3
puts text.scan(/\d/).join(", ")

# Replace digits with '#'
# Output: I have # cats and # dogs
puts text.gsub(/\d/, '#')

Use Cases of Regex

Regular expressions are commonly used in real-world programming tasks, such as:

• Validating input formats (e.g., emails, phone numbers).
• Searching for specific keywords in text.
• Extracting parts of strings (e.g., digits, words).
• Replacing matched patterns with new values.