AppDividend
Latest Code Tutorials

Golang Variables Scope: What is the Scope of Variables In Go

A scope in Golang is the region of a program where a defined variable can exist, and beyond that, a variable cannot be accessed. The variable’s scope can be defined as a part of the program where the specific variable is accessible. A variable can be defined in the class, method, loop, etc. Just Like C/C++, in Go, all identifiers are lexically (or statically) scoped; for example, the scope of the variable can be determined at compile time.

Scope of Variables In Golang

There are three places where the variables can be declared in Golang.

  • Local variables
  • Global variables
  • Formal parameters

Let us deep dive into what are local and global variables and what formal parameters are.

Local variables in Golang

Local variables are those declared inside a function or a block. Local variables can be used only by statements that are inside that function or block of code.

However, these variables can be accessed by a nested code block inside the function.

These variables are also called block variables.

There will be a compile-time error if these variables are declared twice with the same name in the same scope.

The variable which is declared outside the for loop is also accessible within the nested loops. It means the global variable will be accessible to the methods.

The local variable will be accessible to a loop and function inside that function.

See the following code example.

// hello.go

package main

import "fmt"

func main() {
	var GenY, GenZ int = 21, 11
	fmt.Printf("The value of GenY is : %d\n", GenY)
	fmt.Printf("The value of GenZ is : %d\n", GenZ)
}

Output

go run hello.go
The value of GenY is : 21
The value of GenZ is : 11

In the above code, we have defined two variables inside the main() function. Local variables are not known to functions outside their own.

Global variables in Golang

Global variables are defined outside of the function, usually on top of the program.

They hold their value throughout the program’s lifetime, and they can be accessed inside any of the functions defined for a program.

In short, the variables which are defined outside of the function or a block is termed as Global variables. These are available throughout the lifetime of a program.

Global variables are declared at the top of the program outside all of the functions or blocks.

Global variables can be accessed from any portion of the program.

See the following code.

// hello.go

package main

import "fmt"

/* global variable declaration */
var s int

func main() {
	/* local variable declaration */
	var r, h int

	/* actual initialization */
	r = 11
	h = 21
	s = r + h

	fmt.Printf("value of r = %d\n", r)
	fmt.Printf("value of h = %d\n", h)
	fmt.Printf("value of s = %d\n", s)
}

Output

go run hello.go
value of r = 11
value of h = 21
value of s = 32

What will happen if a local variable with the same name as that of the global variable inside the function?

The answer is simple. The compiler will give the preference to a local variable.

Usually when two variable with the same name is defined, then a 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.

See the following code.

// hello.go

package main

import "fmt"

/* global variable declaration */
var k int = 11

func main() {
	/* local variable declaration */
	var k, b int

	/* initialization */
	k = 19
	b = 21

	fmt.Printf("value of k = %d\n", k)
	fmt.Printf("value of b = %d\n", b)
}

Output

go run hello.go
value of k = 19
value of b = 21

Formal Parameters in Golang

Formal parameters are treated as the local variables within that function, and they take preference over the global variables.

See the following code for more understanding.

// hello.go

package main

import "fmt"

/* global variable declaration */
var x int = 20

func main() {
	/* local variable declaration in main function */
	var x int = 10
	var y int = 20
	var z int

	fmt.Printf("value of x in main() function = %d\n", x)
	z = sum(x, y)
	fmt.Printf("value of z in main() function = %d\n", z)
}

/* function to add two integers */
func sum(a, b int) int {
	fmt.Printf("value of a in sum() function = %d\n", a)
	fmt.Printf("value of b in sum() function = %d\n", b)

	return a + b
}

Output

go run hello.go
value of x in main() function = 10
value of a in sum() function = 10
value of b in sum() function = 20
value of z in main() function = 30

In the above example, we have defined x in the global and local scope.

When we call the function, it will pass the value of local scope and not the global scope; that is why the output value of z is 30 and not 40.

Initializing Local and Global Variables in Go

Local and global variables are initialized to their default value, which is 0;

 Go Pointers are initialized to nil.

Conclusion

Scoping is linked closely with a declaration of identifier (being more precise with where an identifier is declared).

The scope of an identifier is a part of the source code (or even all) where the identifier binds to specific values like a variable, constant, package, etc.

Finally, the Scope of Variables In Golang example is over.

See Also

Installing Golang on MacOS

var Keyword in Golang

Golang Custom Type Declaration

Keywords in Golang

Rune in Golang

Leave A Reply

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.