Method declaration with def in Ruby - Step-by-Step Execution

Concept Flow - Method declaration with def

Start

↓

Write def method_name

↓

Add method body

↓

End with 'end'

↓

Method ready to call

↓

Call method to run code

↓

Execute method body

↓

Return result or nil

↓

End

This flow shows how to declare a method using def, write its body, end it, and then call it to run the code inside.

Execution Sample

Ruby

def greet
  puts "Hello!"
end

greet

This code declares a method greet that prints Hello! and then calls it.

Execution Table

Step	Action	Evaluation	Output
1	Define method greet	Method greet created
2	Call greet	Method greet starts
3	Execute puts "Hello!"	Prints Hello!	Hello!
4	Method greet ends	Returns nil
5	Program ends	No more code

💡 Method greet finished execution and program ends

Variable Tracker

Variable	Start	After 1	After 2	Final
Method greet	undefined	defined	called	defined

Key Moments - 2 Insights

Why do we need the 'end' keyword after the method body?

The 'end' keyword tells Ruby where the method finishes. Without it, Ruby doesn't know where the method stops, causing errors. See execution_table step 4 where method ends.

What happens if we call the method before defining it?

Ruby will give an error because the method doesn't exist yet. The method must be defined first as shown in execution_table step 1 before calling it in step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is printed when the method greet is called?

A "greet"

B "Hello!"

C Nothing

D An error message

💡 Hint

Check execution_table row 3 where puts "Hello!" outputs Hello!

At which step does the method greet finish execution?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at execution_table row 4 where method greet ends and returns nil

If we remove the 'end' keyword, what will happen?

A The method will run normally

B The method will return nil automatically

C Ruby will raise a syntax error

D The method will print "end"

💡 Hint

Refer to key_moments about the importance of 'end' keyword and execution_table step 4

Concept Snapshot

def method_name
  # method body
end

- Use def to start method declaration
- Write code inside method body
- Close with end keyword
- Call method by its name to run
- Methods return last evaluated value or nil

Full Transcript

This visual trace shows how to declare a method in Ruby using def. First, we write def followed by the method name. Then we add the code inside the method body. We finish the method with the end keyword. After defining, we call the method by its name to run the code inside. The example method greet prints Hello! when called. The execution table shows each step: defining the method, calling it, printing output, and ending the method. Variables track the method state from undefined to defined and called. Key moments explain why the end keyword is needed and why methods must be defined before calling. The quiz tests understanding of output, method end step, and syntax errors without end.

Practice

1. What keyword do you use in Ruby to start defining a method?

easy

A. method

B. function

C. define

D. def

Solution

1. Step 1: Understand Ruby method syntax

   In Ruby, methods start with the keyword def and end with end.

2. Step 2: Identify the correct keyword

   The correct keyword to start a method is def, not function, method, or define.

3. Final Answer:

   def -> Option D

4. Quick Check:

   Method start keyword = def [OK]

Hint: Remember: Ruby methods start with 'def' and end with 'end' [OK]

Common Mistakes:

• Using 'function' like in JavaScript
• Using 'method' keyword which doesn't exist
• Forgetting to use 'def' to start method

2. Which of the following is the correct way to declare a method named greet in Ruby?

easy

A. def greet puts "Hello"

B. function greet() { puts "Hello" }

C. def greet() puts "Hello" end

D. method greet() puts "Hello" end

Solution

1. Step 1: Check Ruby method syntax

   Ruby methods start with def method_name() and end with end. Parentheses are optional but allowed.

2. Step 2: Identify correct syntax

   def greet() puts "Hello" end uses def greet() puts "Hello" end, which is correct Ruby syntax. Options B and D use wrong keywords, and C misses end.

3. Final Answer:

   def greet() puts "Hello" end -> Option C

4. Quick Check:

   Correct Ruby method syntax = def greet() puts "Hello" end [OK]

Hint: Use 'def name() ... end' to declare methods in Ruby [OK]

Common Mistakes:

• Forgetting the 'end' keyword
• Using JavaScript style 'function' keyword
• Missing parentheses or using wrong keywords

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

def add(a, b)
  a + b
end

puts add(3, 4)

medium

A. 7

B. 34

C. a + b

D. Error

Solution

1. Step 1: Understand method parameters and return

   The method add takes two parameters a and b and returns their sum a + b.

2. Step 2: Calculate the method call result

   Calling add(3, 4) returns 3 + 4 = 7, which is printed by puts.

3. Final Answer:

   7 -> Option A

4. Quick Check:

   3 + 4 = 7 [OK]

Hint: Method returns last expression value; 3 + 4 = 7 [OK]

Common Mistakes:

• Thinking it concatenates as strings
• Expecting explicit return keyword
• Confusing output with code text

4. Identify the error in this Ruby method declaration:

def say_hello
  puts "Hello"

medium

A. Missing 'end' keyword to close method

B. Missing parentheses after method name

C. Incorrect use of puts inside method

D. Method name cannot have underscore

Solution

1. Step 1: Check method structure

   Ruby methods must start with def and end with end. This code misses the end keyword.

2. Step 2: Identify the missing part

   Without end, Ruby will raise a syntax error because the method is not properly closed.

3. Final Answer:

   Missing 'end' keyword to close method -> Option A

4. Quick Check:

   Every method needs 'end' [OK]

Hint: Always close methods with 'end' keyword [OK]

Common Mistakes:

• Forgetting 'end' after method body
• Thinking parentheses are mandatory
• Assuming underscores are invalid in names

5. You want to create a method greet_person that takes a name and returns a greeting like "Hello, Alice!". Which code correctly does this?

hard

A. def greet_person(name)
puts "Hello, #{name}!"
end

B. def greet_person(name)
"Hello, " + name + "!"
end

C. def greet_person(name)
return puts "Hello, " + name + "!"
end

D. def greet_person(name)
print "Hello, " + name + "!"
end

Solution

1. Step 1: Understand method return vs output

   To return a greeting string, the method should produce the string as its last expression or use return. Using puts or print outputs to console but returns nil.

2. Step 2: Analyze each option

   def greet_person(name) "Hello, " + name + "!" end returns the greeting string correctly. def greet_person(name) puts "Hello, #{name}!" end prints but returns nil. def greet_person(name) return puts "Hello, " + name + "!" end returns nil because puts returns nil. def greet_person(name) print "Hello, " + name + "!" end prints but does not return the string.

3. Final Answer:

   def greet_person(name) "Hello, " + name + "!" end -> Option B

4. Quick Check:

   Return string, not print it [OK]

Hint: Return string directly; puts prints but returns nil [OK]

Common Mistakes:

• Using puts instead of returning string
• Returning result of puts (which is nil)
• Confusing print with return