Accessing Variables in Local Environment in R

As a beginner in R, it’s common to encounter situations where variables from one function or block are being accessed in another. In this article, we’ll delve into the concept of local environments in R and explore how to access variables within those environments.

Understanding Local Environments

In programming languages like R, each function or block is associated with its own local environment. A local environment is a dictionary-like data structure that stores all the variables and their values that are defined within a particular scope. When you define a variable within a function or block, it’s automatically added to the local environment of that function or block.

In contrast, global variables are those that are defined outside any specific function or block. Global variables are shared across all functions and blocks in an R program, unless explicitly modified.

The Example

Let’s consider an example from Hadley Wickham’s Advanced R book, where he discusses the preference given to local variable over global variable.

h <- function() {
  x <- 10
  function() {
    x
  }
}
i <- h()
x <- 20
i()

In this code:

h() returns a new function that has its own local environment.
Within the returned function, x is assigned the value 10, which becomes part of the local environment of that function.
The variable x from the outer scope (main()) is used instead of the one from the inner function. This happens because R’s lookup order for variables in a function follows this order: outer, then locals.

x <- 20
i()

Here, we assign x to be equal to 20. However, when we call i(), it uses the value of x from its own local environment (which is set to 10). So, the output will be 10.

Now let’s try a different approach.

x <- 0
y <- 10

f <- function() {
  x <- 1
  g()
}

g <- function() {
  x <- 2
  y <- 5 # Updated by me
  h(y)
}

h <- function(y) {
  x <- 3
  x + y
}

f()

In this example:

We first assign values to x and y.
The function g() updates the value of y within its local environment.
When we call h(), it uses the updated value of y from its own local environment.

f()

Now, let’s see what happens when we run this code. We get an output of 13. Why? Because R looks up variables in this order: outer scope, function locals, global environment, and then it goes back to the main program flow.

However, if we update y like so:

g <- function() {
  x <- 2
  y <- 5 #Note the &lt;&lt;- operator.
  h()
}

Here, R will look up y in its global environment. As a result, y is updated to 5, not just within g().

f()

Now, we get an output of 8. This makes sense since y has been updated in the global scope.

Conclusion

In this article, we explored how R’s local environments work and how variables can be accessed within those environments. We also looked at some common gotchas that beginners might encounter when working with functions and blocks in R. By understanding how R handles variable scope, you’ll be better equipped to write efficient and effective code.

Accessing Variables in Local Environment in R

Understanding Local Environments

The Example

Conclusion

Further Reading