Go Variables

In this tutorial, you will learn what a variable is and how to declare, initialize and use different types of variables in the Go programming language.


A variable is nothing but a name provided to a storage location that can store data. It is the way to represent memory location using symbols so that it can be easily identified. The value of the variable can be changed and reuse many times.

The name of the variable should be unique across the program in order to easily identify.

Each variable is associated with a data type. Data types define the type of data and range of values that can be stored in the variable. Below are a few examples of the Go data type.

Data Type Description
int Stores integer values like 5, 10, etc.
float32 Represents 32-bit floating-point numbers
String Stores string e.g. “tutorial”
Boolean Stores boolean values either true or false

To know more about various data types, you can visit our tutorial Go Data Types.

Go variable syntax

Let’s check the syntax of the Go variable.

var variable_list optional_data_type;

Here,

  • variable_list – variable_list can be made with one or more identifier names separated by commas.
  • optional_data_type – Optional. This defines valid data types such as int, float32, boolean, complex64, or any other user-defined object. This is optional because the type of the variable can be automatically decided by the Go compiler as per the value assigned in it.

Go variable example

Below are the some of valid variable declarations-

var a, b, c int;
var i = 1;
var mark, salary float32;

Go variable can be initialized during the declaration itself. The type of the variable is optional here, Go compiler can automatically decide the type of the variable based on the initialized value. For example-

var x int = 10;
//or
var x = 10;

In this example, var x = 10; define a variable x with data type int (integer) and the initialized value is 10.

package main

import "fmt"

func main() { 
var cnt int // variable declaration
fmt.Println("Value of count is", cnt)
}

If you do not initialize a variable the default value will be the zero value of their data type. Here, the variable cnt is an integer type and the initial value for int is 0.

Go single variable declaration

In the following example, we will check a simple Go program with the single variable declaration.

package main

import "fmt"

func main() {
var count int // variable declaration
fmt.Println("The value of count is =", count)
}

Output

The value of count is = 0

The statement var count int declares a variable named count and the type of the variable is int. Also we have not assigned any value into it. Go compiler assign zero value of it’s type if any variable is declared but not initialized. You can see in the output that it has printed the value of the count as 0 . Go has assigned automatically  the value of count = 0 as for int type the zero value is 0.

Once the variable is declared, the value can be assign to it anytime.

For example:

package main

import "fmt"

func main() {
     var count int // variable declaration
     count = 10
     fmt.Println("The value of count is =", count)
     count = 11
     fmt.Println("The new value of count is =", count)
}

Output

The value of count is = 10
The value of count is = 11

Go variable declaration with an initial value

A variable can also be declared and initialized at the same time.

Syntax

The below is the syntax for declaring a variable with an initial value.

var variable_name type = initial_value

Example

package main

import "fmt"

func main() {
var count int =20 // variable declaration with initial value
fmt.Println("The value of count is =", count)
}

output

The value of count is = 20

In the above program value of the variable count has been initialized with the value 20.

Type inference

It is not mandatory to declare the type of the variable in Go programming always. If the variable has been assigned an initial value, Go automatically infer the type of the variable using the initial value.

Syntax

var variable_name = initial_value

Example

package main

import "fmt"

func main() {
var count = 10 // variable declaration with initial value
fmt.Println("The value of count is =", count)
}

You can notice from the above example that the type of the variable count hasn’t mentioned. But it has been initialized with 10. Go will automatically infer its type as int.

Output

The value of count is = 10

Short hand declaration

Another popular way to declare the Go variable is using short hand variable. In this case, := is used to declare and initialized a variable.

Syntax

variable_name := initial_value

Example

Below is an example of a short hand declaration.

package main

import "fmt"

func main() {
count := 20 // variable declaration using short hand declaration
fmt.Println("The value of count is =", count)
}

In the above example, the variable count is declared and initialized using short hand declaration. It has been initialized with the value 20. Go will automatically infer the type of the count as int as it has been initialized with the integer value 20.

Output
The value of count is = 20

Multiple variable declaration

It is also possible to declare multiple variables in a single statement.

Syntax

var variable_name1, variable_name2 type = initialvalue1, initialvalue2

Example

package main

import "fmt"

func main() { 
var min, max int = 5, 100 //declaring multiple variables

fmt.Println("Minimum value is", min, "Maximum value is", max)
}

In the above example, the statement var min, max int = 5, 100 declares two variables min and max of int type and initialized with the value  5 and 100 respectively.

Output

Minimum value is 5 Maximum value is 100

The type of the variables can be removed if those are declared with the initial values. In the above example, we have initial value for variables so type can be removed.

package main

import "fmt"

func main() { 
var min, max = 5, 100 //declaring multiple variables

fmt.Println("Minimum value is", min, "Maximum value is", max)
}

There might be the case when we need to declare multiple variables of different types in a single statement. In this case the syntax will be as below.

var ( 
variable_name1 = initialvalue1
variable_name2 = initialvalue2
)

The following example shows the declaration of multiple variables of different types.

package main

import "fmt"

func main() { 
var (
name = "Sagar"
age = 30
height int
)
fmt.Println("His name is", name, ", age is", age, "and height is", height)
}

Output

His name is Sagar, age is 30 and height is 0

 

Please get connected & share!

Categories

Advertisement