Method naming conventions (? and ! suffixes) in Ruby - Step-by-Step Execution

Concept Flow - Method naming conventions (? and ! suffixes)

Define method

↓

Check method name suffix

↓

Returns boolean

↓

Use in condition

↓

End method call

Ruby methods ending with ? return true/false; methods ending with ! modify data or are 'dangerous'.

Execution Sample

Ruby

def empty?
  self.size == 0
end

def upcase!
  # modifies string in place
end

Shows a method with ? returning boolean and a method with ! modifying data.

Execution Table

Step	Method Called	Suffix	Behavior	Output/Effect
1	empty?	?	Returns boolean	true or false depending on condition
2	upcase!	!	Modifies object in place	String changed, returns modified string
3	empty?	?	Returns boolean	false if not empty
4	upcase!	!	Modifies object in place	String changed again
5	Call ends	-	-	Program continues

💡 Methods end after returning value or modifying object; suffix guides expected behavior.

Variable Tracker

Variable	Start	After empty? call	After upcase! call	After second upcase! call	Final
string	"hello"	"hello"	"HELLO"	"HELLO"	"HELLO"
empty_check	nil	false	false	false	false

Key Moments - 3 Insights

Why do methods end with a question mark?

Methods ending with ? always return true or false, signaling a yes/no answer, as shown in execution_table rows 1 and 3.

What does the exclamation mark mean in method names?

Methods ending with ! usually change the object itself or do something 'dangerous', as seen in execution_table rows 2 and 4 where the string is modified.

Can a method with ! suffix return a new object instead of modifying?

By convention, ! methods modify the object or have side effects; if it returns a new object, it should be documented clearly. The ! warns to use caution.

Visual Quiz - 3 Questions

Look at the execution_table at step 1, what type of value does the method ending with ? return?

A A boolean value (true or false)

B A modified string

C An integer

D Nothing (nil)

💡 Hint

Check the Behavior and Output/Effect columns in execution_table row 1.

At which step does the method with ! suffix modify the string variable?

A Step 1

B Step 3

C Step 2

D Step 5

💡 Hint

Look at execution_table rows with Method Called 'upcase!' and see the Output/Effect.

If the method empty? returned true at step 1, what would the string variable's size be?

A 1

B 0

C 5

D Cannot tell

💡 Hint

Refer to variable_tracker and the meaning of empty? returning true.

Concept Snapshot

Ruby method names ending with ? return true/false (boolean checks).
Methods ending with ! usually modify the object or perform 'dangerous' actions.
? methods are safe queries; ! methods warn to use with caution.
Use ? for predicates, ! for mutating or risky methods.
This naming helps understand method behavior at a glance.

Full Transcript

In Ruby, methods ending with a question mark (?) always return a boolean value, meaning true or false. This helps us quickly check conditions, like if a string is empty. Methods ending with an exclamation mark (!) usually change the object they are called on or do something that might be risky. For example, upcase! changes the string itself to uppercase. The question mark tells us the method is safe and just checks something, while the exclamation mark warns us to be careful because it changes data. The execution table shows calls to empty? returning true or false, and calls to upcase! modifying the string. The variable tracker shows how the string changes after upcase! calls. Remember, ? means 'asks a question' and returns true/false, ! means 'dangerous or modifies'. This naming helps us understand what methods do just by looking at their names.

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