All About Variables & Constants

Chapter 4


Declaring variables can be done using the var keyword or using the short declaration symbol :=.

var i int // default value is 0
i := 10 // implicit type declaration, i is of type int
j := i // j is also an int

var statements can be at both package or function levels.

Short declarations with := is only available at the function level. := uses implicit type declaration, i.e. it infers the type of the variable from the declaration. This is known as type inference.

Initialising Variables#

We can initialise multiple variables on the same line.

var i, j, k int = 1, 2, 3

Basic Types in Go#

int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32
// represents a Unicode code point
float32 float64
complex64 complex128

The int, uint, and uintptr types are usually 32 bits wide on 32-bit systems and 64 bits wide on 64-bit systems.

Zero Values#

When we declare a variable without an initial value, it takes on a default zero value.

Zero value for types:

  • int takes 0
  • boolean takes false
  • string takes ""

Type Conversions#

In Go, we need to explicitly convert between types. Implicitly converting int to float or vice versa is not allowed.

var x int = 1
var y float64 = float64(x)

Exported Names#

To make a variable or as we will see later for methods, we name it starting with a capital letter, e.g. Ball. Variables starting with a lowercase alphabet is not exported, and hence, will be not be accessible outside the package, e.g. oranges.

Named Return Values#

func namedReturn(num int) (a, b int) {
a = num / 2
b = num / 3
return a, b
func main() {
i, j := namedReturn(6)
fmt.Println(i, j) // prints 3, 2

We can also omit the a, b in the return statement of namedReturn function. This is known as a naked return. However, this is only recommended for short functions so as to maintain code readbility.

Exercise: Swap 2 Variables

i := 100
j := 5
fmt.Println(i ,j) // prints 100, 5
i, j = j, i
fmt.Println(i ,j) // prints 5, 100

In Go, we can swap the values stored in two variables in just one line as shown above (similar to Python).


Constants can be declared with the const keyword.

const x = 100

Note: := is only used for variables. You cannot use it for constants.