Method naming conventions (? and ! suffixes) in Ruby - Mini Project: Build & Apply

Method naming conventions (? and ! suffixes)

📖 Scenario: You are building a simple Ruby program to check and modify strings. In Ruby, methods that end with ? usually return true or false, and methods that end with ! usually change the object itself.

🎯 Goal: You will create methods with ? and ! suffixes to practice Ruby naming conventions. You will write a method to check if a string contains vowels and another method to remove vowels from the string permanently.

📋 What You'll Learn

Create a method called contains_vowels? that returns true if the string has any vowels.

Create a method called remove_vowels! that removes vowels from the string permanently.

Use the ? suffix for the method that returns a boolean.

Use the ! suffix for the method that modifies the string.

Print the results to show the methods work as expected.

💡 Why This Matters

🌍 Real World

These naming conventions help programmers quickly understand if a method will just check something or if it will change data. This is useful when working on bigger Ruby projects or with other developers.

💼 Career

Knowing Ruby method naming conventions is important for writing clear, maintainable code. Many Ruby jobs expect you to follow these conventions to avoid bugs and improve teamwork.

1

Create a string variable

Create a variable called word and set it to the string "hello world".

Ruby

# Create a variable called word and set it to "hello world"
# Your code here

Hint

Use = to assign the string to the variable word.

2

Create the contains_vowels? method

Define a method called contains_vowels? that takes a string parameter called str and returns true if str contains any vowels (a, e, i, o, u), otherwise false. Use the ? suffix in the method name.

Ruby

word = "hello world"
# Define contains_vowels? method below
# Your code here

Hint

Use a regular expression to check for vowels and return true or false.

3

Create the remove_vowels! method

Define a method called remove_vowels! that takes a string parameter called str and removes all vowels from it permanently. Use the ! suffix in the method name to show it modifies the string.

Ruby

word = "hello world"
def contains_vowels?(str)
  !!(str =~ /[aeiou]/i)
end
# Define remove_vowels! method below
# Your code here

Hint

Use gsub! to change the string by removing vowels.

4

Test and print the results

Call contains_vowels? with word and print the result. Then call remove_vowels! with word and print word again to show it changed.

Ruby

word = "hello world"
def contains_vowels?(str)
  !!(str =~ /[aeiou]/i)
end
def remove_vowels!(str)
  str.gsub!(/[aeiou]/i, '')
end
# Print contains_vowels?(word) result
# Call remove_vowels!(word) and print word
# Your code here

Hint

Use puts to print the results.

Practice

1. Which method name follows Ruby convention for a method that returns a boolean value?
? is used at the end of method names that return true or false.

easy

A. save

B. update!

C. calculate

D. valid?

Solution

1. Step 1: Understand the meaning of ? suffix

   In Ruby, methods ending with ? return true or false, indicating a boolean check.

2. Step 2: Identify the method that returns a boolean

   Among the options, valid? clearly suggests a boolean check, while others do not.

3. Final Answer:

   valid? -> Option D

4. Quick Check:

   Boolean methods end with ? = valid? [OK]

Hint: Boolean methods end with ? to show true/false result [OK]

Common Mistakes:

• Confusing ! with ? suffix
• Using ? for methods that modify objects
• Not using ? for boolean-returning methods

2. Which of the following method names is correctly written to indicate it modifies the object in Ruby?

easy

A. delete

B. delete!

C. delete?

D. deleted

Solution

1. Step 1: Understand the meaning of ! suffix

   In Ruby, methods ending with ! usually modify the object or perform a 'dangerous' action.

2. Step 2: Identify the method that modifies the object

   delete! clearly indicates modification, while delete may not, and delete? suggests a boolean check.

3. Final Answer:

   delete! -> Option B

4. Quick Check:

   Modification methods end with ! = delete! [OK]

Hint: Use ! for methods that change the object [OK]

Common Mistakes:

• Using ? instead of ! for modifying methods
• Not adding ! for dangerous methods
• Confusing method names without suffixes

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

class User
  def active?
    true
  end

  def deactivate!
    @active = false
    "User deactivated"
  end
end

user = User.new
puts user.active?
puts user.deactivate!
puts user.active?

medium

A. true
User deactivated
true

B. true
User deactivated
false

C. false
User deactivated
false

D. true
User deactivated
nil

Solution

1. Step 1: Analyze the active? method

   This method always returns true because it returns the literal true without checking any variable.

2. Step 2: Analyze the deactivate! method and second active? call

   deactivate! sets @active = false but active? does not use @active, so it still returns true.

3. Final Answer:

   true User deactivated true -> Option A

4. Quick Check:

   active? returns true always = true User deactivated true [OK]

Hint: Check if boolean method uses instance variables or fixed return [OK]

Common Mistakes:

• Assuming deactivate! changes active? output
• Confusing method side effects
• Ignoring method return values

4. Identify the error in this Ruby method definition:

def save?
  # saves the object
  puts "Saving..."
  true
end

What is wrong with this method name?

medium

A. Method name cannot contain ?

B. Method should end with ! instead of ?

C. Method ends with ? but performs an action, not a boolean check

D. No error, method is correct

Solution

1. Step 1: Understand the meaning of ? suffix

   Methods ending with ? should return true or false and not perform side effects like saving.

2. Step 2: Analyze the method behavior

   This method prints "Saving..." which is a side effect, so it should not end with ?.

3. Final Answer:

   Method ends with ? but performs an action, not a boolean check -> Option C

4. Quick Check:

   Methods with ? should not have side effects [OK]

Hint: ? means boolean check, not side effects [OK]

Common Mistakes:

• Using ? for methods that change state
• Ignoring method side effects
• Confusing ! and ? suffix meanings

5. You want to write a Ruby method that checks if a string is empty and also a method that clears the string content. Which method names follow Ruby conventions?

hard

A. empty? and clear!

B. empty! and clear?

C. empty and clear!

D. empty? and clear

Solution

1. Step 1: Identify boolean check method

   The method checking if a string is empty should return true or false, so it should end with ?, e.g., empty?.

2. Step 2: Identify modifying method

   The method that clears the string modifies it, so it should end with !, e.g., clear!.

3. Final Answer:

   empty? and clear! -> Option A

4. Quick Check:

   Boolean check ends with ?; modifying method ends with ! [OK]

Hint: Boolean methods end with ?; modifying methods end with ! [OK]

Common Mistakes:

• Swapping ? and ! suffixes
• Not using suffixes for clarity
• Using no suffix for modifying methods