Go Variables and Constants

Go Variables

In programming, a variable is a container that is used to store data. Here's how we can declare a variable in Go programming.

var number int

Here,

• number - name of the variable
• var - keyword used to declare variable
• int - data type associated with the variable

Assign Values to Go Variables

There are 3 ways to assign values to a variable.

Method 1

var number int = 10 

Here, we have assigned an integer value 10 to the number variable.

Method 2

var number = 10

Here, we are not explicitly specifying the data type of the variable. In this case, the compiler automatically detects the type by looking at the value of the variable.

Since the value 10 is an integer, the data type of number is int.

Method 3

number := 10

Here, we are using the := operator to assign the value 10 to the variable number. This is the shorthand notation to assign values to variables.

Important Notes on Go Variables

1. If a variable is not assigned any value, a default value is assigned to it. For example,

var count int
fmt.Println(count)

Here, the count variable prints 0 (default value for int) because we haven't assigned any value to it.

2. In Go, every variable must have a data type associated with it. If not, the program throws an error.

// Error: count variable doesn't have a data type
var count

// count1 is of the int type
var count1 int

// count2 is of the int type
var count2 = 10

Example: Go Variables

package main
import "fmt"

func main() {
 
  // explicitly declare the data type
  var number1 int = 10
  fmt.Println(number1)

 // assign a value without declaring the data type
  var number2 = 20
  fmt.Println(number2)

  // shorthand notation to define variable
  number3 := 30
  fmt.Println(number3)  
}

Output

10
20
30

Changing Value of a Variable

As suggested by the name variable, we can change the value stored in a variable. For example,

// initial value
number := 10
fmt.Println("Initial number value", number) // prints 10

// change variable value
number = 100
fmt.Println("The changed value", number)  // prints 100

Initially, 10 was stored in the variable. Then, its value is changed to 100.

number := 10

// Error code
// assign string data
number = "Hello" 

Creating Multiple Variables at Once

In Go, it's also possible to declare multiple variables at once by separating them with commas. For example,

var name, age = "Palistha", 22

Here, "Palistha" is assigned to the name variable. Similarly, 22 is assigned to the age variable.

The same code above can also be written as:

name, age := "Palistha", 22

Rules of naming Variables

• A variable name consists of alphabets, digits, and an underscore.
• Variables cannot have other symbols ( $, @, #, etc).
• Variable names cannot begin with a number.
• A variable name cannot be a reserved word as they are part of the Go syntax like int, type, for, etc.

By the way, we should always try to give meaningful variable names. This makes your code easier to read and understand.

Constant in Go

Constants are the fixed values that cannot be changed once declared. In Go, we use the const keyword to create constant variables. For example,

const lightSpeed = 299792458 // initial value

// Error! Constants cannot be changed
lightSpeed = 299792460

By the way, we cannot use the shorthand notation := to create constants. For example,

// Error code
const lightSpeed := 299792458