Capture groups in Ruby - Mini Project: Build & Apply

Extracting Names with Capture Groups in Ruby

📖 Scenario: You work at a company that receives customer messages. Each message contains a greeting with the customer's first and last name. You want to extract these names to greet them personally.

🎯 Goal: Build a Ruby program that uses capture groups in a regular expression to extract first and last names from a greeting string.

📋 What You'll Learn

Create a string variable called message with a greeting containing a first and last name.

Create a regular expression variable called name_regex that uses capture groups to find the first and last name.

Use the match method on message with name_regex to get the match data.

Print the extracted first and last names separately.

💡 Why This Matters

🌍 Real World

Extracting names from customer messages helps personalize communication in customer support and marketing.

💼 Career

Understanding capture groups and regex matching is useful for data extraction, text processing, and automation tasks in software development.

1

Create the greeting message

Create a string variable called message and set it to the exact value "Hello, my name is John Doe."

Ruby

# Create the greeting message string
# Your code here

Hint

Use double quotes and assign the exact greeting text to message.

2

Create the regular expression with capture groups

Create a regular expression variable called name_regex that matches the pattern "Hello, my name is FirstName LastName." and uses capture groups to capture the first and last names as words.

Ruby

message = "Hello, my name is John Doe."
# Create the regular expression with capture groups
# Your code here

Hint

Use parentheses () to create capture groups for first and last names. Use \w+ to match word characters.

3

Match the regular expression to extract names

Use the match method on message with name_regex and assign the result to a variable called match_data.

Ruby

message = "Hello, my name is John Doe."
name_regex = /Hello, my name is (\w+) (\w+)\./
# Use match method to get match_data
# Your code here

Hint

Call match on message with name_regex and save the result.

4

Print the extracted first and last names

Print the first name by accessing match_data[1] and the last name by accessing match_data[2], each on its own line.

Ruby

message = "Hello, my name is John Doe."
name_regex = /Hello, my name is (\w+) (\w+)\./
match_data = message.match(name_regex)
# Print first and last names
# Your code here

Hint

Use puts to print each captured group from match_data.

Practice

1. What does a capture group do in a Ruby regular expression like /(\d{3})-(\d{2})/?

easy

A. It repeats the pattern multiple times.

B. It saves parts of the matched text for later use.

C. It matches only digits without saving.

D. It ignores the matched text.

Solution

1. Step 1: Understand capture groups in regex

   Capture groups are parts of a pattern enclosed in parentheses that save matched text.

2. Step 2: Analyze the example pattern

   The pattern /(\d{3})-(\d{2})/ has two capture groups for three digits and two digits separated by a dash.

3. Final Answer:

   It saves parts of the matched text for later use. -> Option B

4. Quick Check:

   Capture groups = save matched parts [OK]

Hint: Parentheses in regex save matched text as groups [OK]

Common Mistakes:

• Thinking capture groups repeat patterns
• Confusing capture groups with non-capturing groups
• Believing capture groups ignore matched text

2. Which of the following is the correct syntax to create a capture group in a Ruby regex?

easy

A. /(abc)/

B. /[abc]/

C. /{abc}/

D. /abc/

Solution

1. Step 1: Identify capture group syntax

   Capture groups in Ruby regex are created by enclosing the pattern in parentheses ().

2. Step 2: Compare options

   /(abc)/ uses parentheses correctly. /[abc]/ uses square brackets which match any one character. /{abc}/ uses curly braces which are quantifiers. /abc/ has no capture group.

3. Final Answer:

   /(abc)/ -> Option A

4. Quick Check:

   Parentheses = capture group [OK]

Hint: Use parentheses () for capture groups in regex [OK]

Common Mistakes:

• Using square brackets [] instead of parentheses
• Using curly braces {} incorrectly
• Forgetting parentheses for capture groups

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

text = "Order 123-45"
match = text.match(/(\d{3})-(\d{2})/)
[match[0], match[1], match[2]]

medium

A. ["123-45", "45", "123"]

B. ["12345", "123", "45"]

C. ["Order 123-45", "123", "45"]

D. ["123-45", "123", "45"]

Solution

1. Step 1: Understand match and capture groups

   The match method returns a MatchData object. match[0] is the full matched string, match[1] and match[2] are the first and second capture groups.

2. Step 2: Apply to given string and pattern

   The pattern matches "123-45" in the text. The first group captures "123", the second "45".

3. Final Answer:

   ["123-45", "123", "45"] -> Option D

4. Quick Check:

   Full match + groups = ["123-45", "123", "45"] [OK]

Hint: match[0] full, match[1..] capture groups [OK]

Common Mistakes:

• Confusing full match with capture groups
• Swapping capture group order
• Ignoring the dash in the match

4. What is wrong with this Ruby code snippet?

text = "abc123"
match = text.match(/(\d{3})/)
puts match[1]

medium

A. It prints "123" correctly.

B. It raises an error because there is no match.

C. It prints nil without error.

D. It raises a syntax error.

Solution

1. Step 1: Check the regex and string

   The regex /(\d{3})/ looks for exactly three digits. The string "abc123" contains "123" which matches.

2. Step 2: Understand match and output

   The match object captures "123" in group 1. puts match[1] prints "123".

3. Final Answer:

   It prints "123" correctly. -> Option A

4. Quick Check:

   Digits found and printed = "123" [OK]

Hint: Check if regex matches before accessing groups [OK]

Common Mistakes:

• Assuming no match causes error
• Expecting nil instead of matched string
• Confusing syntax error with runtime error

5. Given a string of dates like "2023-04-01, 2024-12-31", which Ruby code correctly extracts all year parts using capture groups?

hard

A. dates.scan(/\d{4}-\d{2}-\d{2}/)

B. dates.match(/(\d{4})-\d{2}-\d{2}/)

C. dates.scan(/(\d{4})-\d{2}-\d{2}/).flatten

D. dates.match(/\d{4}/)

Solution

1. Step 1: Understand the goal and methods

   We want all years from multiple dates. scan finds all matches, match finds only first.

2. Step 2: Analyze each option

   dates.scan(/(\d{4})-\d{2}-\d{2}/).flatten uses scan with a capture group for year, returning all years as array. dates.match(/(\d{4})-\d{2}-\d{2}/) uses match which returns only first match. dates.scan(/\d{4}-\d{2}-\d{2}/) uses scan but no capture group, returns full dates. dates.match(/\d{4}/) uses match without capture group, only first year.

3. Final Answer:

   dates.scan(/(\d{4})-\d{2}-\d{2}/).flatten -> Option C

4. Quick Check:

   scan + capture group = all years [OK]

Hint: Use scan with capture groups to get all matches [OK]

Common Mistakes:

• Using match instead of scan for multiple matches
• Not using capture groups to extract parts
• Forgetting to flatten nested arrays from scan