Common patterns and character classes in Ruby - Mini Project: Build & Apply

Common patterns and character classes

📖 Scenario: You are working on a simple text processing tool that needs to find specific patterns in a string. This is useful for searching and validating text like phone numbers, emails, or codes.

🎯 Goal: Build a Ruby program that uses regular expressions with common patterns and character classes to find all vowels in a given string.

📋 What You'll Learn

Create a string variable with a specific sentence.

Create a regular expression pattern using character classes to match vowels.

Use the pattern to find all vowels in the string.

Print the list of vowels found.

💡 Why This Matters

🌍 Real World

Finding patterns like vowels, digits, or specific characters is common in text processing, data validation, and search features.

💼 Career

Understanding regular expressions and character classes is essential for roles in software development, data analysis, and quality assurance.

1

Create the text string

Create a string variable called text and set it to the exact value "Hello, Ruby learners!".

Ruby

# Create a string variable called text with the value "Hello, Ruby learners!"
# Your code here

Hint

Use double quotes to create the string exactly as shown.

2

Create a vowel pattern

Create a regular expression variable called vowel_pattern that matches any vowel character (a, e, i, o, u) using a character class. Use the pattern /[aeiou]/i to match vowels case-insensitively.

Ruby

text = "Hello, Ruby learners!"
# Create a regular expression vowel_pattern to match vowels (a, e, i, o, u) case-insensitively
# Your code here

Hint

Use square brackets [] to create a character class and add i after the slash for case-insensitive matching.

3

Find all vowels in the text

Use the scan method on text with vowel_pattern to find all vowels. Store the result in a variable called vowels.

Ruby

text = "Hello, Ruby learners!"
vowel_pattern = /[aeiou]/i
# Use scan method on text with vowel_pattern and store in vowels
# Your code here

Hint

The scan method returns all matches as an array.

4

Print the vowels found

Print the vowels array using puts vowels.inspect to show all vowels found in the text.

Ruby

text = "Hello, Ruby learners!"
vowel_pattern = /[aeiou]/i
vowels = text.scan(vowel_pattern)
# Print the vowels array
# Your code here

Hint

Use puts vowels.inspect to print the array in a readable format.

Practice

1. Which Ruby regular expression pattern matches any single digit character?

easy

A. /\D/

B. /\d/

C. /\s/

D. /\w/

Solution

1. Step 1: Understand \d in Ruby regex

   The pattern \d matches any digit character (0-9).

2. Step 2: Compare with other options

   \w matches word characters (letters, digits, underscore), \s matches whitespace, \D matches non-digit characters.

3. Final Answer:

   /\d/ -> Option B

4. Quick Check:

   Digit pattern = /\d/ [OK]

Hint: Remember \d means digit, \w means word character [OK]

Common Mistakes:

• Confusing \d with \w
• Using /\D/ which matches non-digits
• Thinking \s matches digits

2. Which of the following is the correct Ruby syntax to match any word character one or more times?

easy

A. /\w+/

B. /\w*/

C. /\w?/

D. /\w{}/

Solution

1. Step 1: Understand quantifiers in regex

   + means one or more times, * means zero or more, ? means zero or one.

2. Step 2: Apply to \w

   /\w+/ matches one or more word characters, which is the correct syntax.

3. Final Answer:

   /\w+/ -> Option A

4. Quick Check:

   One or more word chars = /\w+/ [OK]

Hint: Use + for one or more matches in regex [OK]

Common Mistakes:

• Using * which allows zero matches
• Using ? which allows zero or one match
• Using empty braces {} which is invalid

3. What is the output of this Ruby code?

text = "Room 101"
match = text.match(/\d+/)
puts match[0]

medium

A. 101

B. Room

C. 1

D. nil

Solution

1. Step 1: Understand the regex /\d+/

   This pattern matches one or more digits in a row.

2. Step 2: Apply match to string "Room 101"

   The digits "101" are matched as a group, so match[0] returns "101".

3. Final Answer:

   101 -> Option A

4. Quick Check:

   Digits matched = 101 [OK]

Hint: \d+ grabs all digits in a row, not just one [OK]

Common Mistakes:

• Thinking it matches only one digit
• Confusing match[0] with match object
• Expecting the word part instead of digits

4. Find the error in this Ruby code snippet:

email = "[e-mail]"
if email =~ /\w+@\w+.\w+/
  puts "Valid email"
else
  puts "Invalid email"
end

medium

A. The regex should use \d instead of \w

B. The =~ operator is used incorrectly

C. The regex does not escape the dot properly

D. The string should be in single quotes

Solution

1. Step 1: Examine the regex pattern

   The pattern /\w+@\w+.\w+/ uses an unescaped . which matches any character, not a literal dot.

2. Step 2: Identify the error

   The dot after the domain must be escaped as \. to match the literal "." in email addresses.

3. Final Answer:

   The regex does not escape the dot properly -> Option C

4. Quick Check:

   Escape literal dot as \. [OK]

Hint: Remember to escape dot as \. to match literal dot [OK]

Common Mistakes:

• Thinking dot doesn't need escaping
• Misusing =~ operator
• Confusing \w with \d in email regex

5. You want to extract all words starting with a capital letter from the string "Hello World from Ruby". Which Ruby regex pattern should you use with scan?

hard

A. /\d+/

B. /\b[a-z]\w*/

C. /\s+/

D. /\b[A-Z]\w*/

Solution

1. Step 1: Understand the requirement

   We want words starting with a capital letter, so first letter must be A-Z.

2. Step 2: Analyze the regex options

   /\b[A-Z]\w*/ matches word boundary, then capital letter, then zero or more word chars.

3. Step 3: Check other options

   /\b[a-z]\w*/ matches lowercase start, /\d+/ matches digits, /\s+/ matches spaces, so they don't fit.

4. Final Answer:

   /\b[A-Z]\w*/ -> Option D

5. Quick Check:

   Capital-start words = /\b[A-Z]\w*/ [OK]

Hint: Use \b for word boundary and [A-Z] for capital letters [OK]

Common Mistakes:

• Using [a-z] instead of [A-Z]
• Forgetting word boundary \b
• Using digit or space patterns incorrectly