1. Introduction
In this tutorial, we’ll talk about how to work with the different Groovy scopes and see how we can take advantage of its variable scope
2. Dependencies
Throughout, we’ll use the groovy-all and spock-core dependencies
dependencies {
compile 'org.codehaus.groovy:groovy-all:2.4.13'
testCompile 'org.spockframework:spock-core:1.1-groovy-2.4'
}
3. All Scopes
Scopes in Groovy follow, above all, the rule that all variables are created public by default. This means that, unless specified, we’ll be able to access any variable we created from any other scope in the code.
We will see what these scopes mean and to tests this we will run Groovy scripts. To run a script we only need to run:
groovy <scriptname>.groovy
3.1. Global Variables
The easiest way to create a global variable in a Groovy script is to assign it anywhere in the script without any special keywords. We don’t even need to define the type:
x = 200
Then, if we run the following groovy script:
x = 200
logger = Logger.getLogger("Scopes.groovy")
logger.info("- Global variable")
logger.info(x.toString())
we’ll see that we can reach our variable from the global scope.
3.2. Accessing Global Variables from Function Scope
Another way of accessing a global variable is by using the function scope:
def getGlobalResult() {
return 1 + x
}
This function is defined within the scope script. We add 1 to our global x variable.
If we run the following script:
x = 200
logger = Logger.getLogger("Scopes.groovy")
def getGlobalResult() {
logger.info(x.toString())
return 1 + x
}
logger.info("- Access global variable from inside function")
logger.info(getGlobalResult().toString())
We will get 201 as a result. This proves that we can access our global variable from the local scope of a function.
3.3. Creating Global Variables from a Function Scope
We can also create global variables from inside a function scope. In this local scope, if we don’t use any keyword in creating the variable, we’ll create it in the global scope. Let’s, then, create a global variable z in a new function:
def defineGlobalVariable() {
z = 234
}
and try and access it by running the following script:
logger = Logger.getLogger("Scopes.groovy")
def defineGlobalVariable() {
z = 234
logger = Logger.getLogger("Scopes.groovy")
logger.info(z.toString())
}
logger.info("- function called to create variable")
defineGlobalVariable()
logger.info("- Variable created inside a function")
logger.info(z.toString())
We will see that we can access z from the global scope. So this finally proves that our variable has been created in the global scope.
3.4. Non-Global Variables
In the case of non-global variables, we’ll have a quick look at variables created for the local scope only.
Specifically, we’ll be looking at keyword def. This way, we define this variable to be part of the scope where the thread is running.
So, let’s try and define a global variable y and a function-local variable:
logger = Logger.getLogger("ScopesFail.groovy")
y = 2
def fLocal() {
def q = 333
println(q)
q
}
fLocal()
logger.info("- Local variable doesn't exist outside")
logger.info(q.toString())
If we run this script, it will fail. The reason why it’s failing is that q is a local variable, which belongs to the scope of function fLocal. Since we create q with the def keyword, we won’t be able to access it via the global scope.
Evidently, we can access q using the fLocal function:
logger = Logger.getLogger("ScopesFail.groovy")
y = 2
def fLocal() {
def q = 333
println(q)
q
}
fLocal()
logger.info("- Value of the created variable")
logger.info(fLocal())
So now we can see that even though we have created one q variable, that variable isn’t available anymore in other scopes. If we call fLocal again, we’ll just create a new variable.
4. Conclusion
In this article, we have seen how Groovy scopes are created and how they can be accessed from different areas in the code.
As always, the full source code for the examples is available over on GitHub.
