Variables

Variables in R are containers used to store data values. They serve as references, or pointers, to objects in memory. When a variable is assigned a value, it points to the memory location where the value is stored. Variables in R can hold vectors, collections of vectors, or combinations of various R objects.

Example:

# Assigning a value using the equal sign
num_values = c(4, 5, 6, 7)
print(num_values)

# Assigning values using the leftward arrow
languages <- c("JavaScript", "R")
print(languages)

# Assigning a vector
numbers = c(10, 20, 30)
print(numbers)

names = c("Alice", "Bob", "Carol")
print(names)

# Creating a list of vectors
combined_list = list(numbers, names)
print(combined_list)

Output:

[1] 4 5 6 7
[1] "JavaScript" "R"
[1] 10 20 30
[1] "Alice" "Bob" "Carol"
[[1]]
[1] 10 20 30

[[2]]
[1] "Alice" "Bob" "Carol"

Naming Conventions for Variables

Variable names in R must follow these rules:

• They must start with an alphabet.
• Only alphanumeric characters, underscores (_), and periods (.) are allowed.
• Special characters such as !, @, #, $ are not allowed.

Example:

# Valid variable names
value1 = 15
student_name = "John"
course.Name = "Data Science"

# Invalid variable names
# 1value = 20
# student@name = "John"

Error:

Error: unexpected symbol in "1value"
Error: unexpected symbol in "student@name"

Scope of Variables

Global Variables: Global variables are accessible throughout the program. They are usually declared outside all functions and remain in memory until the program ends.

Example:

# Defining a global variable
global_value = 42

# Function accessing the global variable
show_value = function() {
  print(global_value)
}

show_value()

# Updating the global variable
global_value = 100
show_value()

Output:

[1] 42
[1] 100

Local Variables: Local variables exist only within the scope of the function or block in which they are defined. They are not accessible outside that block.

Example:

my_function = function() {
  # Defining a local variable
  local_value = 25
}

# Attempting to access the local variable
print(local_value)

Error:

Error in print(local_value) : object 'local_value' not found

To access the value, use print() within the function:

my_function = function() {
  local_value = 25
  print(local_value)
}

my_function()

Output:

[1] 25

Accessing Global Variables: Global variables are accessible across the program, but local variables are restricted to their scope.

Example:

set_value = function() {
  # Local variable
  local_var <- 15
}

set_value()
print(local_var)

Error:

Error in print(local_var) : object 'local_var' not found

To create or modify global variables inside a function, use the super assignment operator (<<-):

set_global = function() {
  # Making a global variable
  global_var <<- 50
  print(global_var)
}

set_global()
print(global_var)

Output:

[1] 50
[1] 50

Lexical Scoping in R programming means that the values of the free variables are searched for in the environment in which the function was defined. An environment is a collection of symbols, value, and pair, every environment has a parent environment it is possible for an environment to have multiple children but the only environment without the parent is the empty environment. If the value of the symbol is not found in the environment in which the function was defined then the search is continued in the parent environment. In R, the free variable bindings are resolve by first looking in the environment in which the function was created. This is called Lexical Scoping.

Why Lexical Scoping?

Lexical scoping determines how R identifies the value of a variable based on the function’s definition rather than its execution context. This built-in behavior simplifies understanding variable resolution in R. Lexical scoping allows users to focus solely on the function’s definition, rather than its invocation, to predict how variables are resolved. This concept is especially beneficial in statistical computations.

The term “lexical” in lexical scoping originates from the concept of “lexing” in computer science, which is the process of breaking down code into meaningful units that can be interpreted by a programming language.

Example:

f <- function(a, b) {
  a + b + c
}

c <- 5
f(2, 3)

Output:

[1] 10

In this case:

• a and b are formal arguments.
• c is a free variable. Its value is retrieved from the environment where the function was defined.

Principles of Lexical Scoping

There are four fundamental principles of lexical scoping in R:

1. Name Masking
2. Functions vs Variables
3. A Fresh Start
4. Dynamic Lookup

1. Name Masking: When a variable’s name is not defined within a function, R looks for the variable in the parent environment.

Example:

x <- 15
y <- function(a, b) {
  a + b + x
}

y(5, 10)

Output:

[1] 30

Explanation: The function adds 5, 10, and the value of x from the global environment.

If a variable is defined inside the function, it masks the variable from the parent environment.

Example:

x <- 20
y <- function() {
  x <- 5
  x + 10
}

y()

Output:

[1] 15

Explanation: The local definition of x within the function takes precedence.

2. Functions vs Variables: R applies the same scoping rules to functions and variables.

Example:

f <- function(x) x * 2
g <- function() {
  f <- function(x) x + 5
  f(3)
}

g()

Output:

[1] 8

3. A Fresh Start: Every time a function is called, R creates a new environment, ensuring that the function’s execution is independent of previous calls.

Example:

a <- function() {
  if (!exists("y")) {
    y <- 10
  } else {
    y <- y + 10
  }
  y
}

a()

Output:

[1] 10

4. Dynamic Lookup: Lexical scoping resolves where to look for variable values, but the lookup occurs at the time of function execution.

Example:

h <- function() z + 5
z <- 10
h()

Output:

[1] 15

Identifying Global Variables

The findGlobals() function from the codetools package identifies global variables used within a function. This can help in understanding external dependencies.

Example:

xGlobal <- runif(5)
yGlobal <- runif(5)

f <- function() {
  x <- xGlobal
  y <- yGlobal
  plot(y ~ x)
}

codetools::findGlobals(f)

Output:

[1] "{"       "~"       "<-"      "xGlobal" "yGlobal" "plot"