Why Scan for all matches in Ruby? - Purpose & Use Cases

The Big Idea

What if you could find every hidden word in a text with just one simple command?

The Scenario

Imagine you have a long paragraph and you want to find every time a certain word appears. Doing this by reading and checking each word one by one is like searching for a needle in a haystack by hand.

The Problem

Manually checking each word is slow and tiring. You might miss some matches or count some twice. It's easy to make mistakes and it takes a lot of time, especially if the text is very long.

The Solution

Using the scan method in Ruby lets you quickly find all matches of a pattern in a string. It does the hard work for you, returning all matches at once, so you don't have to check each word yourself.

Before vs After

✗ Before

words = text.split(' ')
matches = []
words.each do |word|
  matches << word if word == 'ruby'
end

✓ After

matches = text.scan(/ruby/)

What It Enables

It makes finding all occurrences of a pattern in text fast, easy, and error-free.

Real Life Example

Say you want to find every hashtag in a tweet. Using scan, you can grab all hashtags instantly without missing any.

Key Takeaways

Manually searching text is slow and error-prone.

scan finds all matches quickly and accurately.

This saves time and reduces mistakes when working with text.

Practice

1. What does the Ruby method scan do when used on a string?

easy

A. It counts the number of characters in the string.

B. It replaces all matches of a pattern with another string.

C. It finds all matches of a pattern and returns them in an array.

D. It converts the string to uppercase.

Solution

1. Step 1: Understand the purpose of scan

   The scan method searches the string for all occurrences of a pattern.

2. Step 2: Identify the return value of scan

   It returns an array containing all matched parts of the string.

3. Final Answer:

   It finds all matches of a pattern and returns them in an array. -> Option C

4. Quick Check:

   scan returns matches array [OK]

Hint: Remember: scan returns all matches as an array [OK]

Common Mistakes:

• Confusing scan with gsub (replacement)
• Thinking scan returns a count
• Assuming scan modifies the original string

2. Which of the following is the correct syntax to find all digits in a string str using scan?

easy

A. str.scan(/d+)

B. str.scan("\\d+")

C. str.scan('\d+')

D. str.scan(/\d+/)

Solution

1. Step 1: Recognize the correct regex syntax in Ruby

   Ruby uses forward slashes /pattern/ to denote regular expressions.

2. Step 2: Identify the correct regex for digits

   \d+ matches one or more digits. The pattern must be inside slashes for regex.

3. Final Answer:

   str.scan(/\d+/) -> Option D

4. Quick Check:

   Regex in slashes with \d+ = str.scan(/\d+/) [OK]

Hint: Use /pattern/ for regex, not strings, in scan [OK]

Common Mistakes:

• Using string quotes instead of regex slashes
• Missing escape backslash in regex
• Using incorrect regex delimiters

3. What is the output of the following Ruby code?

text = "cat bat rat"
matches = text.scan(/.at/)
puts matches.inspect

medium

A. ["at", "at", "at"]

B. ["cat", "bat", "rat"]

C. ["c", "b", "r"]

D. []

Solution

1. Step 1: Understand the regex /.at/

   The dot . matches any single character, so .at matches any three-letter word ending with 'at'.

2. Step 2: Apply scan on the string

   The string "cat bat rat" contains "cat", "bat", and "rat" which all match the pattern.

3. Final Answer:

   ["cat", "bat", "rat"] -> Option B

4. Quick Check:

   scan finds all 3-letter words ending with 'at' [OK]

Hint: Dot matches any char; scan returns all full matches [OK]

Common Mistakes:

• Thinking dot matches zero or multiple chars
• Expecting partial matches like 'at' only
• Confusing scan output with string split

4. The following code is intended to find all words starting with 'a' in sentence. What is the error?

sentence = "apple banana apricot avocado"
words = sentence.scan("a\w+")
puts words.inspect

medium

A. The pattern should be a regex, not a string.

B. The pattern should use double backslashes.

C. The method scan does not work on strings.

D. The variable name 'words' is invalid.

Solution

1. Step 1: Check the argument type for scan

   The scan method expects a regex pattern, not a plain string.

2. Step 2: Identify correct regex usage

   The pattern should be written as /a\w+/ to match words starting with 'a'.

3. Final Answer:

   The pattern should be a regex, not a string. -> Option A

4. Quick Check:

   scan requires regex pattern, not string [OK]

Hint: Use /pattern/ for regex in scan, not string quotes [OK]

Common Mistakes:

• Passing string instead of regex to scan
• Misunderstanding backslash escaping
• Assuming scan modifies the string

5. Given the string data = "log12 ID123, ID456, ID789", how can you use scan to extract only the numeric parts after each 'ID' (e.g., ["123", "456", "789"])?

hard

A. data.scan(/ID(\d+)/).flatten

B. data.scan(/\d+/)

C. data.scan(/ID\d+/)

D. data.scan(/(ID\d+)/)

Solution

1. Step 1: Understand the pattern to extract numbers after 'ID'

   The regex /ID(\d+)/ matches 'ID' followed by digits, capturing only digits in parentheses. This ignores other digits like '12' in 'log12'.

2. Step 2: Use scan and flatten the result

   scan returns an array of arrays for capture groups, so flatten converts it to a simple array of strings.

3. Final Answer:

   data.scan(/ID(\d+)/).flatten -> Option A

4. Quick Check:

   Capture group extracts digits, flatten simplifies array [OK]

Hint: Use capture groups and flatten to get inner matches [OK]

Common Mistakes:

• Using data.scan(/\d+/) which grabs all digits including extras like '12' and '78'
• Using scan without flatten, getting nested arrays
• Matching full 'ID123' instead of just digits