Why Common patterns and character classes in Ruby? - Purpose & Use Cases

The Big Idea

Discover how a few symbols can save you hours of tedious searching!

The Scenario

Imagine you need to find all phone numbers or email addresses in a long text by checking each character one by one.

The Problem

Doing this by hand is slow and tiring. You might miss some patterns or make mistakes because the rules are tricky and many characters look similar.

The Solution

Using common patterns and character classes lets you describe groups of characters easily. This way, Ruby can quickly find what you want without checking every single character manually.

Before vs After

✗ Before

text.each_char { |c| check if c is digit or letter }

✓ After

text.scan(/\d{3}-\d{3}-\d{4}/)

What It Enables

You can quickly search and match complex text patterns with simple, readable rules.

Real Life Example

Extracting all phone numbers from customer messages to contact them faster.

Key Takeaways

Manual character checks are slow and error-prone.

Character classes group similar characters for easy matching.

Common patterns let Ruby find text quickly and accurately.

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