Match operator (=~) in Ruby - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the Ruby match operator =~ do?

It checks if a string matches a pattern defined by a regular expression. It returns the index of the first match or nil if no match is found.

beginner

What is the return value of "hello" =~ /e/ in Ruby?

It returns 1 because the letter 'e' is found at index 1 in the string "hello".

beginner

What does the match operator =~ return if there is no match?

It returns nil, which means no match was found in the string.

beginner

How can you use the match operator =~ in an if statement?

You can write if string =~ /pattern/ to check if the pattern exists in the string. If it matches, the condition is true; otherwise, false.

intermediate

What is the difference between =~ and match method in Ruby?

=~ returns the index of the match or nil. The match method returns a MatchData object with detailed info about the match.

What does "cat" =~ /a/ return in Ruby?

A nil

B 1

C 0

D true

The letter 'a' is at index 1 in "cat", so the match operator returns 1.

What is the result of "dog" =~ /z/?

A 0

B false

C nil

D -1

No 'z' in "dog", so the match operator returns nil.

Which of these is true about the match operator =~?

A Returns index of match or nil

B Returns true or false

C Returns the matched string

D Returns a boolean and the matched string

It returns the index where the match starts or nil if no match.

How can you check if a string contains digits using =~?

A string =~ /\d/

B string =~ /[a-z]/

C string =~ /\w/

D string =~ /\s/

The regex /\d/ matches any digit character.

What does if str =~ /pattern/ do in Ruby?

A Never runs code

B Runs code if pattern is not found

C Always runs code

D Runs code if pattern is found

The condition is true if the pattern matches the string.

Explain how the Ruby match operator =~ works with strings and regular expressions.

Think about what happens when you look for a pattern inside a word.

Describe how you would use the match operator =~ inside an if statement to check for a pattern.

Remember how Ruby treats nil in conditions.

Practice

1. What does the Ruby operator =~ do when used like string =~ /pattern/?

easy

A. Splits the string into an array based on the pattern

B. Returns true if the pattern is found, false otherwise

C. Replaces the pattern in the string with another string

D. Returns the index where the pattern starts in the string or nil if not found

Solution

1. Step 1: Understand the operator's purpose

   The =~ operator checks if a regex pattern matches anywhere in the string.

2. Step 2: Know the return value

   It returns the index of the first match or nil if no match is found.

3. Final Answer:

   Returns the index where the pattern starts in the string or nil if not found -> Option D

4. Quick Check:

   =~ returns index or nil [OK]

Hint: Remember: =~ returns index or nil, not true/false [OK]

Common Mistakes:

• Thinking it returns true or false
• Confusing it with string replacement
• Assuming it splits the string

2. Which of the following is the correct syntax to check if the string "hello123" contains digits using the match operator?

easy

A. "hello123" =~ /\d+/

B. "hello123" =~ "\d+"

C. "hello123" =~ /\w+/

D. "hello123" =~ /[a-z]+/i

Solution

1. Step 1: Identify correct regex syntax

   The pattern to match digits is /\d+/, which is a regex literal in Ruby.

2. Step 2: Match operator requires regex, not string

   The =~ operator expects a regex on the right side, so /\d+/ is correct, not a string.

3. Final Answer:

   "hello123" =~ /\d+/ -> Option A

4. Quick Check:

   Regex literal with =~ is correct [OK]

Hint: Use slashes /pattern/ for regex with =~ operator [OK]

Common Mistakes:

• Using a string instead of regex on right side
• Confusing \d with \w for digits
• Missing regex delimiters

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

text = "OpenAI GPT-4"
index = text =~ /GPT/
puts index

medium

A. nil

B. 0

C. 7

D. SyntaxError

Solution

1. Step 1: Locate the pattern in the string

   The string is "OpenAI GPT-4". The substring "GPT" starts at index 7 (counting from 0).

2. Step 2: Understand what =~ returns

   The operator returns the index of the first match, so it returns 7.

3. Final Answer:

   7 -> Option C

4. Quick Check:

   Index of "GPT" in string = 7 [OK]

Hint: Count characters from zero to find match index [OK]

Common Mistakes:

• Counting from 1 instead of 0
• Expecting true/false instead of index
• Assuming nil if unsure

4. Identify the error in this Ruby code snippet:

str = "test123"
result = str =~ "\d+"
puts result

medium

A. Using a string instead of a regex pattern with =~

B. Missing parentheses around =~ operator

C. Incorrect variable name 'str'

D. Using puts instead of print

Solution

1. Step 1: Check the right side of =~ operator

   The code uses a string "\d+" instead of a regex literal /\d+/.

2. Step 2: Understand =~ expects regex

   The match operator requires a regex pattern, so using a string causes a TypeError or unexpected behavior.

3. Final Answer:

   Using a string instead of a regex pattern with =~ -> Option A

4. Quick Check:

   Right side of =~ must be regex [OK]

Hint: Always use /pattern/ regex, not strings, with =~ [OK]

Common Mistakes:

• Using strings instead of regex
• Thinking parentheses are needed
• Confusing puts with print

5. Given the array words = ["cat", "dog", "bird", "cow"], which code snippet uses the match operator to find the first word containing the letter 'i' and returns its index in the array?

hard

A. words.find { |w| w =~ /i/ }

B. words.find_index { |w| w =~ /i/ }

C. words.index { |w| w.include?('i') }

D. words.select { |w| w =~ /i/ }

Solution

1. Step 1: Understand the goal

   We want the index of the first word containing 'i'.

2. Step 2: Use find_index with match operator

   find_index returns the index of the first element where the block is true. Using w =~ /i/ returns index or nil, so truthy means match found.

3. Step 3: Check other options

   words.index { |w| w.include?('i') } uses include? which works but is not using the match operator. words.find { |w| w =~ /i/ } returns the word, not index. words.select { |w| w =~ /i/ } returns all matches, not index.

4. Final Answer:

   words.find_index { |w| w =~ /i/ } -> Option B

5. Quick Check:

   find_index with =~ returns correct index [OK]

Hint: Use find_index with =~ to get index of first match [OK]

Common Mistakes:

• Using find instead of find_index for index
• Using include? instead of =~
• Expecting select to return single index