Why regex is powerful in Ruby - See It in Action

Why regex is powerful in Ruby

📖 Scenario: You are working on a simple text processing task where you need to find and extract specific patterns from a string. Ruby's regular expressions (regex) make this easy and powerful.

🎯 Goal: Learn how to use Ruby regex to find all words that start with a capital letter in a sentence.

📋 What You'll Learn

Create a string variable with a sentence containing several words, some starting with capital letters

Create a regex pattern to match words starting with a capital letter

Use Ruby's regex methods to find all matching words

Print the list of matched words

💡 Why This Matters

🌍 Real World

Regex is used in many real-world tasks like searching text, validating input, and extracting data from documents.

💼 Career

Knowing regex in Ruby is valuable for jobs in web development, data processing, and automation where text handling is common.

1

Create the sentence string

Create a string variable called sentence and set it to the exact value: "Ruby is Powerful and Easy to Learn"

Ruby

# Create the string variable 'sentence' with the given text
# Your code here

Hint

Use double quotes to create the string exactly as shown.

2

Create the regex pattern

Create a regex variable called capital_word_pattern that matches words starting with a capital letter. Use the pattern /\b[A-Z][a-z]*\b/

Ruby

sentence = "Ruby is Powerful and Easy to Learn"
# Create the regex variable 'capital_word_pattern' with the pattern /\b[A-Z][a-z]*\b/
# Your code here

Hint

The pattern matches word boundaries, a capital letter, then zero or more lowercase letters.

3

Find all matching words

Use the scan method on sentence with capital_word_pattern to find all words starting with a capital letter. Store the result in a variable called capital_words

Ruby

sentence = "Ruby is Powerful and Easy to Learn"
capital_word_pattern = /\b[A-Z][a-z]*\b/
# Use scan method to find all capitalized words and store in 'capital_words'
# Your code here

Hint

The scan method returns an array of all matches.

4

Print the matched words

Print the variable capital_words to display the list of words starting with a capital letter

Ruby

sentence = "Ruby is Powerful and Easy to Learn"
capital_word_pattern = /\b[A-Z][a-z]*\b/
capital_words = sentence.scan(capital_word_pattern)
# Print the 'capital_words' array
# Your code here

Hint

Use puts to print the array. Each word will appear on its own line.

Practice

1. Why is regex considered powerful in Ruby?

easy

A. It cannot be combined with other Ruby methods.

B. It only works with numbers, not text.

C. It requires complex syntax to use.

D. It can quickly find and manipulate text patterns.

Solution

1. Step 1: Understand regex purpose in Ruby

   Regex is used to find patterns in text efficiently.

2. Step 2: Recognize Ruby's regex flexibility

   Ruby allows easy pattern matching and text manipulation using regex.

3. Final Answer:

   It can quickly find and manipulate text patterns. -> Option D

4. Quick Check:

   Regex power = quick text pattern handling [OK]

Hint: Regex helps find text patterns fast in Ruby [OK]

Common Mistakes:

• Thinking regex only works with numbers
• Believing regex syntax is always complex
• Assuming regex can't be combined with Ruby methods

2. Which of the following is the correct way to write a regex literal in Ruby?

easy

A. /pattern/

B. 'pattern'

C. {pattern}

D. (pattern)

Solution

1. Step 1: Identify Ruby regex syntax

   Ruby uses slashes / / to define regex literals.

2. Step 2: Compare options

   Only /pattern/ matches Ruby regex literal syntax.

3. Final Answer:

   /pattern/ -> Option A

4. Quick Check:

   Regex literal = /pattern/ [OK]

Hint: Regex literals in Ruby use slashes /pattern/ [OK]

Common Mistakes:

• Using quotes instead of slashes
• Using braces or parentheses for regex
• Confusing regex with string syntax

3. What will be the output of this Ruby code?

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

medium

A. hello

B. 123

C. nil

D. error

Solution

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

   This regex matches one or more digits in the string.

2. Step 2: Apply regex to text "hello123"

   The digits "123" match the pattern and are captured.

3. Final Answer:

   123 -> Option B

4. Quick Check:

   Digits found = 123 [OK]

Hint: \d+ matches digits; here it finds '123' [OK]

Common Mistakes:

• Expecting 'hello' as output
• Thinking match returns nil if partial match exists
• Confusing match object with string

4. Find the error in this Ruby code using regex:

text = "abc123"
if text =~ /\d+/
  puts "Digits found"
else
  puts "No digits"
end

medium

A. The regex syntax is incorrect

B. The =~ operator is used wrongly

C. No error; code works as expected

D. Missing parentheses in if condition

Solution

1. Step 1: Check regex syntax

   The regex /\d+/ correctly matches digits.

2. Step 2: Verify use of =~ operator

   The =~ operator checks if regex matches the string; usage is correct.

3. Final Answer:

   No error; code works as expected -> Option C

4. Quick Check:

   Regex and operator usage = correct [OK]

Hint: =~ checks regex match; no parentheses needed [OK]

Common Mistakes:

• Thinking =~ is invalid operator
• Expecting parentheses required in if
• Assuming regex syntax is wrong

5. How can you use regex in Ruby to replace all vowels in a string with '*'?

hard

A. string.gsub(/[aeiou]/i, '*')

B. string.replace(/[aeiou]/, '*')

C. string.sub(/[aeiou]/, '*')

D. string.match(/[aeiou]/).replace('*')

Solution

1. Step 1: Identify method to replace all matches

   gsub replaces all occurrences matching regex in the string.

2. Step 2: Use regex for vowels with case-insensitive flag

   /[aeiou]/i matches all vowels regardless of case.

3. Step 3: Combine to replace vowels with '*'

   string.gsub(/[aeiou]/i, '*') replaces all vowels with '*'.

4. Final Answer:

   string.gsub(/[aeiou]/i, '*') -> Option A

5. Quick Check:

   Replace vowels = gsub with /[aeiou]/i [OK]

Hint: Use gsub with /[aeiou]/i to replace all vowels [OK]

Common Mistakes:

• Using sub replaces only first match
• Using replace method incorrectly
• Trying to call replace on match object