Golang tutorials - Variables starter guide with examples

This blog post, It covers the Golang Tutorials variables guide with examples.

Golang variables

Variables usage in go language is the same as in another programming language such as java.

Variables are the name given to a space in memory where values are stored. These are various types of values that are stored. Based on each type, memory size will be accommodated.

Variable names can be named using letters, digits, and underscore characters. Because the Go language is case-sensitive, upper and lower case names are different.

Variables in go language are declared using the var keyword.

It must first be declared before you can use a variable.

How to declare Variable in Golang?

Variables can be declared using the var keyword. Once variable is declared, the compiler allocates memory based on the type of the variable.

The variable declaration contains three parts

  1. var keywords
  2. variable name
  3. type of variable
var variablename(s) variableType

It can be single or multiple, variable types are predefined inbuilt types or custom types.

Inbuilt types can be byte, int and float32, and string.

Following are a various way of variable declaration examples

initialized variables

It can be declared and initialized with values.

It can be done in many ways. The following example explains converting different types.

package main
import (
func main() {
    m: = 42
    n: = float64(2.0)
    var o float64 = float64(25.2)




Multiple variable declarations

Here multiple variables declare in a single line of the same type.

package main
import (
func main() {
    var a, b, c int;
    var (
        m = 1 n = 20 o = 3

Short variable declarations

variables can be declared and assigned with initial values. Multiple variables declare in a single line and readability is improved and code lines reduced.

package main
import "fmt"
func main() {
    var m, n int = 10,
    fmt.Println(m, n) // 10 20

How to declare Global Scope variables in golang?

variables declared outside function blocks and at the package level.

This variable does access across all functions declared in the program. These can exist as long as the program is running.

package main

import "fmt"

//Global Variables Declaration
var globalVariable = "Hello";
func main() {


And output of the above code is


How to define Local Scope variables?

Variables declared inside a function or block of code is called a local variable. The variables do not access outside the function.

package main
import "fmt"
func main() {
    //Local Variables Declaration
    var localVariable = "this is test variable";


And output of the above code is

this is test variable

Variables default values in golang

These also can be assigned with a default value with values zero for number types such as Int, Float, etc.. false for Boolean types, empty string -” for Strings.

package main

import "fmt"

func main() {
    var intVariable int32
    var floatVariable float32
    var booleanVariable bool
    var strVariable string
    fmt.Printf("%v %v %v %q\n", intVariable, floatVariable, booleanVariable, strVariable) // output 0 0 false ""


Golang type inference

type inference is called When a variable declares without the type of the variable. The type can derive type from the right-hand side of the value.

inference can be applied to variables and constants.

Below example descript using variable expression using = and:= operators.

package main
import "fmt"
func main() {
    var k int
    l: = k
    var m = 42
    var n = false
    p: = 3.2 // constant
    fmt.Printf("variable k datatype is %T\n", k)
    fmt.Printf("variable l datatype is %T\n", l)
    fmt.Printf("variable m datatype is %T\n", m)
    fmt.Printf("variable n datatype is %T\n", n)
    fmt.Printf("variable p datatype is %T\n", p)


The output of the above program code is

variable k datatype is int
variable l datatype is int
variable m datatype is int
variable n datatype is bool
variable p datatype is float64

How to declare Constants in golang

Constants are like variables that can not be changed value, once the value is assigned. Constants can be declared using := syntax. const can be applied to all types of data such as boolean, strings, and numeric types

package main
import "fmt"
func main() {
    const str = "kiran"
    fmt.Println("Hi", str) // Hi kiran
    const booleanValue = true
    fmt.Println(booleanValue) // true

The difference between variable and constant, Constant values are fixed and variables are dynamic. Constant throws an exception if you tried to change its value. Variables change their value at any time.

Let’s see some examples using golang variables.

How to find a memory or address location of a variable?

This example gets variable pointer reference memory in golang.

To get memory location, variables in golang can be referenced using & the variable name - ampersand variable.

  • & the variable is a pointer of a variable which prints the memory location of the variable
  • *& the variable is a value of a variable at memory location

This example prints the pointer of a variable

package main
import "fmt"
func main() {
    var m int
    fmt.Println("memory location for m :", & m, "variable value is ", * & m)
    n: = 15
    fmt.Println("memory location for n :", & n, "variable value is ", * & n)

The output of the above code is

memory location for m : 0x416020 variable value is  0
memory location for n : 0x416024 variable value is  15


In this tutorial, learn how to declare variables and the scope of variables, define fixed values constants and type inference

An example for finding a memory or address location of a variable