Local variables and naming conventions in Ruby - Step-by-Step Execution

Concept Flow - Local variables and naming conventions

Start of method or block

↓

Declare local variable

↓

Assign value to variable

↓

Use variable in code

↓

End of method or block

↓

Variable goes out of scope

Local variables are created inside methods or blocks, used there, and disappear after the block ends.

Execution Sample

Ruby

def greet
  name = "Alice"
  puts "Hello, #{name}!"
end

greet

This code defines a method with a local variable 'name' and prints a greeting using it.

Execution Table

Step	Action	Variable 'name' Value	Output
1	Enter method greet	undefined
2	Assign name = "Alice"	"Alice"
3	Execute puts "Hello, #{name}!"	"Alice"	Hello, Alice!
4	Exit method greet	undefined

💡 Method ends, local variable 'name' goes out of scope and is no longer accessible.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
name	undefined	"Alice"	"Alice"	undefined

Key Moments - 3 Insights

Why can't we use the local variable 'name' outside the method?

Because local variables only exist inside the method where they are defined, as shown in step 4 of the execution_table where 'name' becomes undefined after the method ends.

Can local variable names start with a capital letter?

No, local variable names must start with a lowercase letter or underscore. Starting with a capital letter is reserved for constants or class names.

What characters are allowed in local variable names?

Local variable names can include letters, digits, and underscores, but cannot start with a digit. This follows Ruby's naming conventions.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'name' at Step 3?

A undefined

B "Alice"

C "Bob"

D nil

💡 Hint

Check the 'Variable 'name' Value' column at Step 3 in the execution_table.

At which step does the local variable 'name' become undefined again?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look at the 'Variable 'name' Value' column in the execution_table to see when it changes back to undefined.

If we rename 'name' to 'Name' (capital N), what happens according to Ruby naming conventions?

A It becomes a constant, not a local variable

B It becomes a local variable as usual

C It causes a syntax error

D It becomes a global variable

💡 Hint

Refer to the key_moments about naming conventions for local variables.

Concept Snapshot

Local variables in Ruby:
- Defined inside methods or blocks
- Names start with lowercase letter or underscore
- Exist only during method/block execution
- Disappear after method/block ends
- Cannot be accessed outside their scope

Full Transcript

This visual execution shows how local variables work in Ruby. When a method starts, local variables are undefined. When assigned, they hold values inside the method. Using the variable prints output. After the method ends, the variable disappears and cannot be used outside. Local variable names must start with lowercase letters or underscores and follow Ruby naming rules.

Practice

1. Which of the following is a valid local variable name in Ruby?

easy

A. user_name

B. UserName

C. user-name

D. 1username

Solution

1. Step 1: Check the first character of each variable name

   Local variables must start with a lowercase letter or underscore. 'user_name' starts with 'u' which is lowercase.

2. Step 2: Check for invalid characters

   Variable names cannot contain hyphens or start with numbers. 'user-name' has a hyphen and '1username' starts with a number, so they are invalid.

3. Final Answer:

   user_name -> Option A

4. Quick Check:

   Valid local variable = user_name [OK]

Hint: Local variables start lowercase or underscore, no hyphens or digits first [OK]

Common Mistakes:

• Starting variable names with uppercase letters
• Using hyphens instead of underscores
• Starting variable names with numbers

2. Which of these Ruby variable names will cause a syntax error?

easy

A. temp-var

B. tempVar2

C. _tempVar

D. temp_var

Solution

1. Step 1: Identify invalid characters in variable names

   Ruby variable names can only contain letters, digits, and underscores. Hyphens are not allowed.

2. Step 2: Check each option for invalid characters

   temp-var has a hyphen, which causes a syntax error. The others are valid.

3. Final Answer:

   temp-var -> Option A

4. Quick Check:

   Hyphens cause syntax errors in variable names [OK]

Hint: No hyphens allowed in variable names, use underscores instead [OK]

Common Mistakes:

• Using hyphens instead of underscores
• Confusing uppercase and lowercase letters
• Starting variable names with digits

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

def greet
  name = "Alice"
  Name = "Bob"
  puts name
end
greet

medium

A. name

B. Alice

C. Bob

D. Name

Solution

1. Step 1: Understand variable naming and scope

   In Ruby, local variables start with lowercase letters, constants start with uppercase. 'name' is local variable, 'Name' is a constant.

2. Step 2: Check which variable is printed

   The code prints 'name', which is "Alice". The constant 'Name' is not used in the puts statement.

3. Final Answer:

   Alice -> Option B

4. Quick Check:

   Local variable 'name' prints "Alice" [OK]

Hint: Local variables lowercase, constants uppercase; puts prints local variable [OK]

Common Mistakes:

• Confusing constants with local variables
• Assuming uppercase variable prints
• Ignoring case sensitivity

4. Identify the error in this Ruby code snippet:

def calculate
  total = 10
  Total = 20
  puts Total + total
end
calculate

medium

A. SyntaxError due to variable naming

B. Runtime error: undefined variable

C. No error, outputs 30

D. No error, outputs 10

Solution

1. Step 1: Analyze variable types and naming

   'total' is a local variable, 'Total' is a constant. Both are defined before use.

2. Step 2: Evaluate the expression in puts

   Adding 'Total' (20) and 'total' (10) results in 30. No syntax or runtime errors occur.

3. Final Answer:

   No error, outputs 30 -> Option C

4. Quick Check:

   Constant + local variable sums correctly [OK]

Hint: Constants uppercase, locals lowercase; both can be used together [OK]

Common Mistakes:

• Assuming case-insensitive variables
• Expecting syntax error from uppercase variable
• Confusing constants with local variables

5. You want to create a local variable to store a user's age in Ruby. Which of these variable names follows best naming conventions and is clear to other programmers?

hard

A. UserAge

B. userAge

C. user-age

D. user_age

Solution

1. Step 1: Check Ruby naming conventions for local variables

   Local variables should start with lowercase letters or underscores and use underscores to separate words for clarity.

2. Step 2: Evaluate each option for clarity and convention

   'user_age' uses lowercase and underscores, making it clear and conventional. 'UserAge' starts uppercase (looks like constant), 'user-age' has invalid hyphen, 'userAge' uses camelCase which is less common in Ruby.

3. Final Answer:

   user_age -> Option D

4. Quick Check:

   Use lowercase with underscores for clear local variables [OK]

Hint: Use lowercase and underscores for clear Ruby local variables [OK]

Common Mistakes:

• Using camelCase instead of snake_case
• Starting variable names with uppercase letters
• Using hyphens in variable names