Golang - Chapter 4

All About Variables & Constants

Variables

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

bool

string

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.
https://tour.golang.org/basics/11

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

Constants can be declared with the const keyword.

const x = 100

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

comments powered by Disqus

Related