Scope of Variables in Go

22 Jul, 2019
The Scope of a variable can be defined as a part of the program where a particular variable is accessible. A variable can be defined in a class, method, loop, etc. Like C/C++, in Golang all identifiers are lexically (or statically) scoped, i.e. scope of a variable can be determined at compile time. Or you can say a variable can only be called from within the block of code in which it is defined.
Golang scope rules of variables can be divided into two categories which depend on where the variables are declared:
Local Variables(Declared Inside a block or a function)
Global Variables(Declared outside a block or a function)
Variables that are declared inside a function or a block are termed as Local variables. These are not accessible outside the function or block.
These variables can also be declared inside the for, while statement etc. inside a function.
However, these variables can be accessed by the nested code blocks inside a function.
These variables are also termed as the block variables.
There will be a compile-time error if these variables are declared twice with the same name in the same scope.
These variables don’t exist after the function’s execution is over.
The variable which is declared outside the loop is also accessible within the nested loops. It means a global variable will be accessible to the methods and all loops. The local variable will be accessible to loop and function inside that function.
A variable which is declared inside a loop body will not be visible to the outside of loop body.
Example:
// Go program to illustrate the// local variablespackage main   import "fmt"   // main functionfunc main() { // from here local level scope of main function starts     // local variables inside the main function var myvariable1, myvariable2 int = 89, 45   // Display the values of the variables fmt.Printf("The value of myvariable1 is : %d\n",                                     myvariable1)    fmt.Printf("The value of myvariable2 is : %d\n",                                     myvariable2)    } // here local level scope of main function ends
Output:
The value of myvariable1 is : 89
The value of myvariable2 is : 45

The variables which are defined outside of a function or a block is termed as Global variables.
These are available throughout the lifetime of a program.
These are declared at the top of the program outside all of the functions or blocks.
These can be accessed from any portion of the program.
Example:
// Go program to illustrate the// global variablespackage main   import "fmt"  // global variable declarationvar myvariable1 int = 100  func main() { // from here local level scope starts   // local variables inside the main functionvar myvariable2 int = 200  // Display the value of global variablefmt.Printf("The value of Global myvariable1 is : %d\n",                           myvariable1)   // Display the value of local variablefmt.Printf("The value of Local myvariable2 is : %d\n",                           myvariable2)                   // calling the function            display()  } // here local level scope ends    // taking a functionfunc display() { // local level starts         // Display the value of global variablefmt.Printf("The value of Global myvariable1 is : %d\n",                           myvariable1)      } // local scope ends here
Output:
The value of Global myvariable1 is : 100
The value of Local myvariable2 is : 200
The value of Global myvariable1 is : 100

Note: What will happen there exists a local variable with the same name as that of the global variable inside a function?
The answer is simple i.e. compiler will give preference to the local variable. Usually when two variable with the same name is defined then the compiler produces a compile-time error. But if the variables are defined in different scopes then the compiler allows it. Whenever there is a local variable defined with the same name as that of a global variable then the compiler will give precedence to the local variable.
Example: In the below program, you can clearly see the output. As myvariable1 value is 200 which is giving in function main. So you can say a local variable has a high preference over a global variable.// Go program to show compiler giving preference// to a local variable over a global variablepackage main   import "fmt"   // global variable declarationvar myvariable1 int = 100  func main() { // from here local level scope starts   // local variables inside the main function// it is same as global variablevar myvariable1 int = 200  // Display the value fmt.Printf("The value of myvariable1 is : %d\n",                     myvariable1)                   } // here local level scope endsOutput:The value of myvariable1 is : 200

// Go program to show compiler giving preference// to a local variable over a global variablepackage main   import "fmt"   // global variable declarationvar myvariable1 int = 100  func main() { // from here local level scope starts   // local variables inside the main function// it is same as global variablevar myvariable1 int = 200  // Display the value fmt.Printf("The value of myvariable1 is : %d\n",                     myvariable1)                   } // here local level scope ends
Output:
The value of myvariable1 is : 200

Go-Basics
Golang
Go Language
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Different ways to concatenate two strings in Golang
time.Sleep() Function in Golang With Examples
strings.Replace() Function in Golang With Examples
strings.Contains Function in Golang with Examples
fmt.Sprintf() Function in Golang With Examples
Golang Maps
Time Formatting in Golang
How to Split a String in Golang?
Different ways to compare Strings in Golang
Different Ways to Find the Type of Variable in Golang