Ruby Regular Expressions

Regular Expressions are a special sequence of characters that use a specialized syntax to match or search for sets of strings.

Regular expressions are composed of predefined specific characters and their combinations, forming a "rule string" that expresses a filter logic for strings.

Syntax

Regular Expressions are patterns that can be enclosed between slashes or any delimiter following %r, as shown below:

/pattern/
/pattern/im    # Options can be specified
%r!/usr/local! # Regular expression using a delimiter

Example

#!/usr/bin/ruby

line1 = "Cats are smarter than dogs";
line2 = "Dogs also like meat";

if ( line1 =~ /Cats(.*)/ )
  puts "Line1 contains Cats"
end
if ( line2 =~ /Cats(.*)/ )
  puts "Line2 contains Dogs"
end

The output of the above example is:

Line1 contains Cats

Regular Expression Modifiers

Regular expressions may include optional modifiers to control various aspects of matching. These modifiers are specified after the second slash, as shown in the example. Below is a list of possible modifiers:

Ruby allows you to start a regular expression with %r followed by any delimiter, similar to how strings are delimited by %Q. This is useful when describing patterns that contain many slashes that you do not want to escape.

# Matches a single slash character without escaping
%r|/|               

# Flag characters can be matched with the following syntax
%r[</(.*)>]i

Regular Expression Patterns

Except for control characters, (+ ? . * ^ $ ( ) [ ] { } | ), all other characters match themselves. You can escape a control character by preceding it with a backslash.

The following table lists the regular expression syntax available in Ruby.

Regular Expression Examples

Characters

Character Classes

Special Character Classes

Repetition

Non-greedy Repetition

This matches the smallest number of repetitions.

Grouping with Parentheses

Backreferences

This matches a previously matched group again.

Substitution

Anchors

This requires specifying the matching position.

Special Syntax with Parentheses

Search and Replace

sub and gsub along with their destructive versions sub! and gsub! are important string methods that use regular expression patterns for search and replace operations.

sub and sub! replace the first occurrence of the pattern, while gsub and gsub! replace all occurrences.

sub and gsub return a new string, leaving the original unchanged, whereas sub! and gsub! modify the string they are called on.

Example

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

phone = "138-3453-1111 #This is a phone number"

# Delete Ruby-style comments
phone = phone.sub!(/#.*$/, "")   
puts "Phone Num : #{phone}"

# Remove anything other than digits
phone = phone.gsub!(/\D/, "")    
puts "Phone Num : #{phone}"

The output of the above example is:

Phone Num : 138-3453-1111 
Phone Num : 13834531111

Example

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

text = "rails are rails, Ruby on Rails is a fantastic Ruby framework"

# Replace all occurrences of "rails" to "Rails"
text.gsub!("rails", "Rails")

# Capitalize the word "Rails" throughout
text.gsub!(/\brails\b/, "Rails")

puts "#{text}"

The output of the above example is:

Rails are Rails, Ruby on Rails is a fantastic Ruby framework

Rails is Rails, a very good Ruby framework for Ruby on Rails.