Home » Golang

Variables in Golang

Learn about the variables in Golang, variable declarations, declarations with initializations, etc with the syntaxes and examples. By Anshuman Singh Last updated : December 8, 2023

Go Variables

In Golang, variables are nothing but the names given to a storage area or memory location for storing the data of a specific type. The variables are declared using the var keyword in Golang. There are some other ways to declare variables in Golang, those are explained below.

There are various ways to declare the variables in Golang.

Declare single variable at a time

To declare a single variable in Golang, you need to write the var keyword followed by the variable name and then specify the type of the variable.

Syntax

Here is the syntax to declare a single variable at a time in the Go language:

var variable_name type

Example

package main
import "fmt"

func main() {  
    var student_weight int // variable declaration
    fmt.Println("Student weight is: ", student_weight)
}

In the above example, the statement var student_weight int declares a variable named student_weight of type int.

Output

Student weight is:  0

Here, Output is zero (0). Reason being, when a variable is not assigned with any value. go compiler automatically initializes default value of variable type. Here, the variable type is int so the default value of int is zero (0).

Declare a variable with initial value

To declare a single variable with an initial value in Golang, you need to write the var keyword followed by the variable name, type of the variable, and assign the initial value by using the assignment operator (=).

Syntax

Here is the syntax to declare a variable with initial value in the Go language:

var variable_name type = initial_value

Example

package main

import "fmt"

func main() {  
	// variable declaration with 20 initial value
	var student_weight int = 20

	fmt.Println("Student weight is: ", student_weight)
}

In the above example, The statement var student_weight int = 20 declares a variable named student_weight of type int with initial value 20.

Output

Student weight is: 20

Multiple variable declarations

In go, we can declare multiple variables of the same type in a single statement.

Syntax

Here is the syntax to declare multiple variables in the Go language:

var variable_name_1, variable_name_2, variable_name_3 type

Example

package main

import "fmt"

func main() {  
	// three variable declaration
	var age, height, length int  
	fmt.Printf("age: %d, height: %d, length: %d", age, height, length)
}

In the above example, the statement var age, height, length int declares three variables named age, height, and length of type int.

Output

age: 0, height: 0, length: 0

Here, Go compiler assigns zero value (default value of int) to these variables.

Multiple variable declarations with initial value

In go, we can declare multiple variables of the same type with an initial value in a single statement.

Syntax

Here is the syntax to declare multiple variables with initial values in the Go language:

var variable_name_1, variable_name_2, 
variable_name_3 type = value_1, value_2, value_3

Example

package main

import "fmt"

func main() {  
	// three variable declaration with initial value
	var age, height, length int  = 10,  20, 30 

	fmt.Printf("age: %d, height: %d, length: %d", age, height, length)
}

In the above example, the statement var age, height, length int declares three variables named age, height, and length of type int with initial values 10, 20, 30 respectively.

Output

age: 10, height: 20, length: 30

Type inference

In go, you can declare a variable with initial value without mentioning type. Go will automatically be able to infer the type of that variable using initial value.

Syntax

Here is the syntax to declare a variable with initial value without mentioning type in the Go language:

var variable_name = initial_value

Example

package main

import "fmt"

func main() {  
	// variable declaration with 20 initial value
	var student_weight = 20

	fmt.Println("Student weight is: ", student_weight)
}

Output

Student weight is: 20

In the above example, go can infer it of type int.

Declare a variable and assign value later

In go, you can declare variables and assign values to variables later.

Example

package main

import "fmt"

func main() {  

    var height, weight int

    fmt.Printf("height: %d, weight: %d\n",  height, weight)

    height = 8

    weight = 50

    fmt.Printf("height: %d, weight: %d",  height, weight)
}

Output

height: 0, weight: 0
height: 8, weight: 50

In the above example, 1^st we declare the height and weight variables. Here, go compiler assigns a default value of int. that's why 1^st output has 0 value of height and weight.

Later we assign value to these variables as 8 to height and 50 to weight. So the second output is " height: 8, weight: 50".

Short hand declaration

In short hand declaration, we use := operator.

Syntax

Here is the syntax for the sort hand declaration of a variable in the Go language:

variable_name := initial_value

Example

package main
      
import "fmt"

func main() {  

    height, weight := 10, 20

    fmt.Printf("height: %d, weight: %d\n",  height, weight)

    name := "includehelp"

    fmt.Printf("name: %s", name)
}

Output

height: 10, weight: 20
name: includehelp

Note: Short hand declaration requires initial value of all the variables.

---