Variable scope (lexical scoping) in R Programming - Mini Project: Build & Apply

Variable scope (lexical scoping) in R

📖 Scenario: You are helping a friend understand how variables work inside and outside functions in R. This is important because sometimes variables inside a function can be different from those outside.

🎯 Goal: Build a small R script that shows how variable values change inside a function and how the outside variable stays the same. You will create a variable, write a function that uses a variable with the same name, and then print both to see the difference.

📋 What You'll Learn

Create a variable called number with the value 10

Write a function called change_number that creates a local variable number with value 5 and returns it

Call the function change_number and save its result in a variable called new_number

Print both number and new_number to show their values

💡 Why This Matters

🌍 Real World

Understanding variable scope helps avoid bugs when writing functions that use variables with the same names as outside variables.

💼 Career

Many programming jobs require writing clean functions that do not accidentally change important data outside their scope.

1

Create the initial variable

Create a variable called number and set it to 10.

R Programming

# Create a variable called number and set it to 10
# Your code here

Hint

Use the assignment operator <- to set the value.

2

Write a function with a local variable

Write a function called change_number that creates a local variable number with value 5 and returns number.

R Programming

number <- 10
# Write the function change_number below
# Your code here

Hint

Inside the function, create a variable number and use return() to send it back.

3

Call the function and save the result

Call the function change_number and save its result in a variable called new_number.

R Programming

number <- 10
change_number <- function() {
  number <- 5
  return(number)
}
# Call change_number and save the result in new_number
# Your code here

Hint

Use the function name with parentheses to call it and assign the result.

4

Print both variables to see the difference

Print the variables number and new_number using two separate print() statements.

R Programming

number <- 10
change_number <- function() {
  number <- 5
  return(number)
}
new_number <- change_number()
# Print number and new_number
# Your code here

Hint

Use print(number) and print(new_number) to show their values.

Practice

1. What does lexical scoping mean in R programming?

easy

A. Variables are looked up where the function is defined, not where it is called.

B. Variables are always global and accessible everywhere.

C. Variables inside functions overwrite global variables automatically.

D. Variables are found only inside loops.

Solution

1. Step 1: Understand lexical scoping definition

   Lexical scoping means R looks for variables in the environment where the function was written, not where it is called.

2. Step 2: Compare options with definition

   Only Variables are looked up where the function is defined, not where it is called. correctly describes this behavior; others are incorrect or unrelated.

3. Final Answer:

   Variables are looked up where the function is defined, not where it is called. -> Option A

4. Quick Check:

   Lexical scoping = lookup where defined [OK]

Hint: Remember: R finds variables where code is written, not run [OK]

Common Mistakes:

• Thinking variables are always global
• Confusing lexical with dynamic scoping
• Assuming function variables overwrite globals automatically

2. Which of the following is the correct way to define a local variable x inside a function in R?

easy

A. global x = 5

B. x <- 5 inside the function body

C. var x = 5

D. x := 5

Solution

1. Step 1: Recall R syntax for variable assignment

   In R, variables are assigned using the arrow operator (<-), especially inside functions.

2. Step 2: Check each option

   x <- 5 inside the function body uses correct R syntax. Options B, C, and D use syntax from other languages or invalid forms.

3. Final Answer:

   x <- 5 inside the function body -> Option B

4. Quick Check:

   Use <- for assignment in R [OK]

Hint: Use <- to assign variables inside functions in R [OK]

Common Mistakes:

• Using global or var keywords (not R syntax)
• Using := which is not valid in base R
• Confusing R with other languages like JavaScript or Python

3. What is the output of this R code?

y <- 10
f <- function() {
  y <- 5
  return(y)
}
f()

medium

A. 10

B. NULL

C. 5

D. Error

Solution

1. Step 1: Identify variable scopes

   Global y is 10, but inside function f, y is locally assigned 5.

2. Step 2: Determine returned value

   The function returns the local y, which is 5, not the global y.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Local variable y inside function = 5 [OK]

Hint: Inside function, local variables override globals [OK]

Common Mistakes:

• Assuming function returns global y (10)
• Thinking function returns NULL by default
• Expecting an error due to variable shadowing

4. Consider this R code:

z <- 3
f <- function() {
  z <- z + 1
  return(z)
}
f()

What is the result?

medium

A. 4

B. 3

C. NULL

D. Error: object 'z' not found

Solution

1. Step 1: Analyze variable usage inside function

   Inside f, z <- z + 1 tries to read local z before assignment, but local z doesn't exist yet.

2. Step 2: Understand lexical scoping rules

   R looks for z in local scope first; it is not found, so it does not use global z for the right side in assignment.

3. Step 3: Resulting error

   This causes an error: object 'z' not found.

4. Final Answer:

   Error: object 'z' not found -> Option D

5. Quick Check:

   Local variable used before assignment causes error [OK]

Hint: Local vars must exist before use; else error occurs [OK]

Common Mistakes:

• Assuming global z is used automatically
• Expecting output 4 without error
• Ignoring variable initialization order

5. Given the code below, what will g() return?

a <- 2
f <- function() {
  a <- 3
  h <- function() {
    a <- 4
    return(a)
  }
  return(h())
}
g <- function() {
  return(f())
}
g()

hard

A. 4

B. 3

C. Error

D. 2

Solution

1. Step 1: Trace nested function variable scopes

   Global a = 2, f() sets local a = 3, h() inside f sets local a = 4.

2. Step 2: Determine return value of g()

   g() calls f(), which calls h(), which returns its local a = 4.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Innermost local variable a = 4 returned [OK]

Hint: Innermost function's local variable shadows outer ones [OK]

Common Mistakes:

• Returning outer function's a (3) instead of inner (4)
• Returning global a (2)
• Expecting an error due to nested functions