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, string starts with m)
• . - indicates any one letter or character
• $ - marks the end of a string (Here, 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.

We will learn about regular expressions in detail below.

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.

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 for example - "apache", it doesn't match with pattern because "apache" has more than five characters.

Regex Methods in Ruby

Ruby provides several methods to work with regex:

Example: Using Regex Methods

text = "I have 2 cats and 3 dogs"

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

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

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

Metacharacters

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

Some of the basic metacharacters are:

• [] - square bracket
• . - period
• ^ - caret
• $ - dollar
• * - star
• + - plus
• ? - question mark
• {} - braces
• () - parenthesis
• | - alternation

[]- Square brackets

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

For example,

/[abc]/

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

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

. - Period

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

For example,

/.../

This pattern matchesany three-character substring (except newline).

Let's check if the following string examples match the regex pattern ….

^ - Caret

The caret symbol ^ specifies 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 string examples match the regex pattern ^m.

$ - Dollar

The dollar symbol $ specifies 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 string examples match the regex pattern y$.

* - Star

The star symbol * matches zero or more occurrences of the pattern left to it.

For example,

/ca*t/

This pattern matches strings that have any number[including zero] of a in between c and t

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

+ - Plus

The plus symbol + matches one or more occurrences of the pattern left to it.

/ma+t/

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

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

? - Question Mark

The question mark symbol ? matches zero or one occurrence of the pattern left to it.

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 string examples match the regex pattern ma?n.

{} - Braces

The braces symbol {} is used to specify the range of repetitions of the pattern left to it.

/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 or operator.

For example,

/a|b/

This pattern matches string that has either a or b

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

() - Parenthesis

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 string examples match the regex pattern (ab)+.

Special Sequences

Ruby regex also supports special sequences for common character sets.

\d - 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 string examples match the regex pattern \..