Scope of Variables in Go

Prerequisite: Variables in Go Programming Language

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)

Local Variables

  • 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:



filter_none

edit
close

play_arrow

link
brightness_4
code

// Go program to illustrate the
// local variables
package main 
  
import "fmt"
   
// main function
func 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

chevron_right


Output:

The value of myvariable1 is : 89
The value of myvariable2 is : 45

Global Variables

  • 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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Go program to illustrate the
// global variables
package main 
  
import "fmt"
  
// global variable declaration
var myvariable1 int = 100
  
func main() { // from here local level scope starts 
  
// local variables inside the main function
var myvariable2 int = 200
  
// Display the value of global variable
fmt.Printf("The value of Global myvariable1 is : %d\n"
                          myvariable1) 
  
// Display the value of local variable
fmt.Printf("The value of Local myvariable2 is : %d\n"
                          myvariable2) 
                  
// calling the function            
display()
  
} // here local level scope ends
  
  
// taking a function
func display() { // local level starts 
        
// Display the value of global variable
fmt.Printf("The value of Global myvariable1 is : %d\n"
                          myvariable1) 
     
} // local scope ends here

chevron_right


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.
    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    Output:

    The value of myvariable1 is : 200
    


My Personal Notes arrow_drop_up

Believes in Smart Work

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.