Go Basics Training – Basics

Docs: Variables

Mon, 01 Jan 0001 00:00:00 +0000

Basics

Go is a statically typed language. This means that each variable gets a type on declaration which can’t be changed later.

Commonly used data types are:

int and uint
float32 and float64
bool
string
byte (alias for uint8)
error to return errors from functions

All Go’s predeclared identifiers are defined in the builtin package.

Declaration

The short assignment statement := declares a variable and assigns a value to it. The type of variable is inferred from the value (type inference).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 // type string inferred from "foo.txt"
 name := "foo.txt"

 // type int inferred from 42
 size := 42

 // type bool inferred from true
 isFile := true

 fmt.Println(name, size, isFile)
}

Output:
foo.txt 42 true

Once a variable is declared you can assign values to it with a regular assignment =.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 name := "foo.txt"

 name = "bar.csv"

 fmt.Println(name)
}

Output:
bar.csv

With the var keyword you can declare a variable without assigning a value to it.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 // single variable
 var name string

 // multiple variables
 var (
 size int
 isFile bool
 )

 fmt.Println(name, size, isFile)
}

Output:
0 false

Zero values

If you declare a variable and do not assign a value it is initialized with the zero value of its type.

The zero values are:

0 for numeric types
false for booleans
"" (empty string) for strings

Docs: Flow control

Mon, 01 Jan 0001 00:00:00 +0000

If Else

Conditionals in Go are similiar to other programming languages. Notice that there are no round brackets surrounding the condition.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func main() {
 x := 10
 if x >= 5 {
 fmt.Println("X is greater or equal to 5")
 } else {
 fmt.Println("X is smaller than 5")
 }
}

Output:
X is greater or equal to 5

Multiple logical conditions can be combined with && (AND) and || (OR).

Switch

If you are testing one variable for multiple conditions with else if the code can quickly become confusing. In these cases a switch statement can be used. The last default case is equivalent to else.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package main

import (
 "fmt"
)

func main() {
 dayOfWeek := 3

 switch dayOfWeek {
 case 1:
 fmt.Println("Sunday")
 case 2:
 fmt.Println("Monday")
 case 3:
 fmt.Println("Tuesday")
 case 4:
 fmt.Println("Wednesday")
 case 5:
 fmt.Println("Thursday")
 case 6:
 fmt.Println("Friday")
 case 7:
 fmt.Println("Saturday")
 default:
 fmt.Println("Invalid day")
 }
}

Output:
Tuesday

Loops

The examples below show the basic loop constructs. We will look at an additional variant in the chapter 2.6. Slices.

For - Classical

1
2
3
4
5
6
7
8
9


package main

import "fmt"

func main() {
 for i := 0; i < 5; i++ {
 fmt.Println(i)
 }
}

Output:
0
1
2
3
4

While equivalent

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import "fmt"

func main() {
 i := 0
 for i < 5 {
 fmt.Println(i)
 i++
 }
}

Output:
0
1
2
3
4

Docs: Functions

Mon, 01 Jan 0001 00:00:00 +0000

Basics

The func keyword declares a function.

In the following example we declare the function add. It takes two parameters a and b of type int and returns a value of type int which is the sum of a and b.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func add(a int, b int) int {
 return a + b
}

func main() {
 result := add(2, 3)
 fmt.Println(result)
}

Output:
5

No Return Value

If a function does not return a result the return type can be left out.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package main

import "fmt"

func sayHello(name string) {
 fmt.Println("Hello", name)
}

func main() {
 name := "Bob"
 sayHello(name)
}

Output:
Hello Bob

Multiple Return Values

A function can return multiple values. The following example contains a function sub, which returns two values:

The result of the subtraction of a and b
A boolean which indicates if the result is negative

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func sub(a int, b int) (int, bool) {
 result := a - b
 isNegative := result < 0
 return result, isNegative
}

func main() {
 result, negative := sub(2, 3)
 fmt.Println(result, negative)
}

Output:
-1 true

In Go it is an error to declare variables without using them. If we only need a single value we can discard variables by assigning them to _:

result, _ := sub(2, 3)

Returning Errors

Functions that can fail return error values. In many other languages exceptions are thrown to indicate error conditions. Go does not have exceptions.

Errors are returned from functions like every other return value. From the function signature we can see if a function can fail or not.

Let’s take a look at the function os.ReadFile from the Go standard library. It’s signature looks like this:

func ReadFile(name string) ([]byte, error)

In the function signature we see that the last return value is of type error. So we know that the function can fail. In the case of ReadFile possible errors could be that the file does not exist or that we do not have enough permission to read the file.

If the returned error value is not empty (nil) an error has occurred.

content, err := os.ReadFile("test.txt")
if err != nil {
 // handle error
}

In many cases handling the error means:

Passing the error up to the caller: return err
Logging or printing an error (e.g. print to standard error with fmt.Fprintln )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
 "fmt"
 "os"
)

func main() {
 fileContent, err := os.ReadFile("test.txt")
 if err != nil {
 fmt.Fprintln(os.Stderr, err)
 os.Exit(1)
 }
 fmt.Println(fileContent)
}

Output:
open test.txt: no such file or directory

Function As Values

In Go functions are first-class values. This means that you can pass functions around like ordinary values.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

// run takes a function myfunc and runs it with a and b
func run(a int, b int, myfunc func(int, int) int) int {
 return myfunc(a, b)
}

func main() {
 add := func(a int, b int) int { return a + b }
 sub := func(a int, b int) int { return a - b }

 result1 := run(2, 3, add)
 result2 := run(2, 3, sub)

 fmt.Println(result1, result2)
}

Output:
5 -1

Docs: Pointers

Mon, 01 Jan 0001 00:00:00 +0000

Basics

In addition to the basic data types Go also have pointers. A pointer contains a memory address of an actual value or nil if they do not point to anything. The zero value of a pointer is nil.

Pointer types are indicated with a star. For example:

The type *int is a pointer to an int
The type *bool is a pointer to a bool

Concerning pointers you mainly have to remember two operations. How to create a pointer to a value and how go obtain a value from a pointer:

Operation	Example	Code	Description
Value To Pointer	`int` to `*int`	`myPointer = &myInt`	With the `&` operator you can create a pointer to a value
Value From Pointer	`*int` to `int`	`myInt = *myPointer`	With the `` operator we can obtain the actual value from a pointer (dereference*)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package main

import "fmt"

func main() {
 // declare myPointer as *int. Initially it is nil (zero value)
 var myPointer *int

 // myInt is of type int
 myInt := 42

 // Value To Pointer
 // myPointer becomes pointer to myInt
 myPointer = &myInt

 // Value From Pointer
 // Change myInt through myPointer. We can not assign an int to a *int hence we
 // have to dereference myPointer with * to assign a new number
 *myPointer = 12

 fmt.Println(myInt)
 fmt.Println(*myPointer)
}

Output:
12
12

If you dereference a pointer you should always be sure that it is not nil. Otherwise your program crashes with an error invalid memory address or nil pointer dereference (same as NullPointerException in Java).

Why Use Pointers

If we work with basic data types like int, bool, float64, etc. we rarely use pointers. We introduce the topic at this time because in the next chapter we will get to know about structs. Pointers are often used together with structs.

In Go function arguments are passed by value. This means they are copied in memory and a new variable is created. For large variables like structs this can be a performance problem. To overcome this we can use pointers. With pointers only the memory address to the variable value is passed and the variable itself is not copied. This is called passing values by reference.

Docs: Structs

Mon, 01 Jan 0001 00:00:00 +0000

Basics

Structs are used to group related variables called fields. In that respect structs in Go are similar to classes or objects in other languages.

Declare Struct Type

This statement declares a new struct type called User. This struct contains three fields. The name of the user (string), the number of failed login attempts (int) and if the user is locked (bool):

type User struct {
 Name string
 FailedLogins int
 Locked bool
}

Create Instance

A new struct instance can be created using a struct literal:

myUser := User{
 Name: "admin",
 FailedLogins: 0,
 Locked: false,
}

When createing a new instance you don’t have to specify all struct fields. If a field is not set it is initialized to the zero value of its type.

The following example creates the same struct as the previous example. The field FailedLogins is set to 0 and Locked is set to false since 0 and false are the zero values of int and bool.

myUser := User{
 Name: "admin",
}

Access Struct Fields

The individual fields of a struct are accessed using a dot:

// say hello to the user
fmt.Printf("hello %s", myUser.Name)

// increase the number of failed login attempts
myUser.FailedLogins += 1

// lock to user
myUser.Locked = true

Here you see a full example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import "fmt"

type User struct {
 Name string
 FailedLogins int
 Locked bool
}

func main() {
 myUser := User{
 Name: "admin",
 }

 fmt.Println(myUser)

 myUser.FailedLogins += 1

 if myUser.FailedLogins > 0 {
 myUser.Locked = true
 }

 fmt.Println(myUser)
}

Output:
{admin 0 false}
{admin 1 true}

Structs As Function Arguments

Structs can be passed to functions like any other value. If we pass a struct to a function it gets copied.

func Print(user User) {
 fmt.Println(user.Name)
}

If we want to change a struct within a function we have to pass a pointer to a struct to the function. Otherwise within the function we would only change the copy. Even if we do not change a struct within a function we often just pass a pointer

Consider a function Reset which should reset the failed login attempts and unlock a user. For this function instead of expecting a user User which would only be copy we expect a pointer to a user (*User) as argument:

func Reset(user *User) {
user.FailedLogins = 0
user.Locked = false
}

As we learnt in chapter 2.4. Pointers we can obtain a pointer to a value by preceding it with &:

Reset(&myUser)

We can also directly obtain a pointer to a user *User on creation as follows:

myUser := &User{
 Name: "admin",
}

Reset(myUser)

Full example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import "fmt"

type User struct {
 Name string
 FailedLogins int
 Locked bool
}

func Print(user User) {
 fmt.Println(user.Name, user.Locked)
}

func Reset(user *User) {
 user.FailedLogins = 0
 user.Locked = false
}

func main() {
 // myUser gets type *User because we use &User{} for initialization
 myUser := &User{
 Name: "admin",
 }

 // with *myUser we dereference the *User to obtain a User
 Print(*myUser)

 myUser.Locked = true

 Print(*myUser)

 Reset(myUser)

 Print(*myUser)
}

Output:
admin false
admin true
admin false

Constructors

Go does not have constructors. It is common to use a function NewXxx where Xxx is the struct name.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import "fmt"

type person struct {
 Name string
 Age int
}

func NewPerson(name string, age int) person {
 return person{
 Name: name,
 Age: age,
 }
}

func main() {
 pers := NewPerson("Ursli", 45)
 fmt.Println(pers)
}

Output:
{Ursli 45}

Methods

Instead of passing structs to functions we can attach methods to structs. In the previous example we passed a User or a *User to a function. Sometimes it is more convient to call such a function as method directly on the variable:

myUser.Reset()

// instead of
Reset(myUser)

A method declaration looks like a function declaration. The only difference is that you specify to which struct you want to attach the method between the func keyword and the argument list:

func (user *User) Reset() {
 user.FailedLogins = 0
 user.Locked = false
}

Full example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


package main

import "fmt"

type User struct {
 Name string
 FailedLogins int
 Locked bool
}

func (user User) Print() {
 fmt.Println(user.Name, user.Locked)
}

func (user *User) Reset() {
 user.FailedLogins = 0
 user.Locked = false
}

func main() {
 myUser := &User{
 Name: "admin",
 Locked: true,
 }

 myUser.Print()

 myUser.Reset()

 myUser.Print()
}

Output:
admin true
admin false

Nested Structs

In comparision with other languages Go does not support inheritance. However something similiar can be achieved by using composition:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


package main

import "fmt"

type person struct {
 firstName string
 lastName string
 age int
}

type blogPost struct {
 title string
 content string
 author person
}

func (p person) fullName() {
 // Printf allows us to use placeholders for variables.
 // %v can be used for all variable types.
 // You may also restrict this to %s and %d for strings and digits.
 fmt.Printf("%v %v\n", p.firstName, p.lastName)
}

func main() {
 chrigu := person{
 firstName: "Christian",
 lastName: "Müller",
 age: 28,
 }
 blogPost1 := blogPost{
 // we do not need to specify the struct field names
 "Inheritance in Go",
 "Go supports composition instead of inheritance",
 chrigu,
 }
 blogPost1.author.fullName()
}

Output:
Christian Müller

Embedding

Multiple structs can also be combined. This is called embedding. Notice that we are using the person struct directly in blogPost without giving it a struct field name:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import "fmt"

type person struct {
 firstName string
 lastName string
 age int
}

type blogPost struct {
 title string
 content string
 person
}

func (p person) fullName() {
 fmt.Println(p.firstName, p.lastName)
}

func main() {
 chrigu := person{
 firstName: "Christian",
 lastName: "Müller",
 age: 28,
 }
 blogPost1 := blogPost{
 // we do not need to specify the struct field names
 "Inheritance in Go",
 "Go supports composition instead of inheritance",
 chrigu,
 }
 // Even though we did not specify a struct field name, we can use the type name
 blogPost1.person.fullName()
 // Since the struct is embedded, we can also directly access its fields!
 blogPost1.fullName()
 fmt.Println(blogPost1.firstName)
}

Output:
Christian Müller
Christian Müller
Christian

Docs: Slices

Mon, 01 Jan 0001 00:00:00 +0000

Basics

With a slice literal (e.g. []int{1, 2, 3}) and the short assignment we we can initialize a new slice. Slices store multiple items of the same type.

1
2
3
4
5
6
7
8
9


package main

import "fmt"

func main() {
 q := []int{2, 3, 5, 7, 11, 13}
 fmt.Println(q)
 fmt.Println("Length of slice:", len(q))
}

Output:
[2 3 5 7 11 13]
Length of slice: 6

Slice of structs

We can also store multiple instances of a struct.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

type Person struct {
 name string
 age int
}

func main() {
 people := []Person{
 {name: "Christoph", age: 48},
 {name: "Susanne", age: 35},
 {name: "Peter", age: 29},
 }
 fmt.Println(people)
 fmt.Println(people[1])
}

Output:
[{Christoph 48} {Susanne 35} {Peter 29}]
{Susanne 35}

Appending items

To add items to an existing slice you can use append. Notice that append does not modify the original slice, but returns a new one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import "fmt"

func main() {
 list := []int{1, 2, 3}
 fmt.Println("Initial slice:", list)

 // Add an item to a slice.
 list = append(list, 4)
 fmt.Println("Add one item:", list)

 // Add multiple items
 list = append(list, 5, 6, 7)
 fmt.Println("Add multiple items:", list)
}

Output:
Initial slice: [1 2 3]
Add one item: [1 2 3 4]
Add multiple items: [1 2 3 4 5 6 7]

Loops

In 2.2. Flow control we learned about the basic for loop. However if we want to loop over all the slice elements, we prefer to use range. With range we can iterate over all items of a slice.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import "fmt"

func main() {
 slice := []int{2, 4, 8}
 for index, item := range slice {
 fmt.Println(index, item)
 }
}

Output:
0 2
1 4
2 8

In many cases we discard the index with _ because we only need the actual item:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import "fmt"

func main() {
 slice := []int{2, 4, 8}
 for _, item := range slice {
 fmt.Println(item)
 }
}

Output:
2
4
8

Docs: Maps

Mon, 01 Jan 0001 00:00:00 +0000

Basics

A map maps keys to values. In other languages it is also called hash map or dictionary. The following example shows how to:

initialize a map with an empty map literal
set a value by key
get a value by key
delete a key
get the length of the map

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package main

import "fmt"

func main() {
 m := map[string]int{}
 m["john"] = 66
 fmt.Println("john", m["john"])
 fmt.Println("len", len(m))
 delete(m, "john")
 fmt.Println("john", m["john"]) // the zero value is returned, if the item does not exist
 fmt.Println("len", len(m))
}

Output:
john 66
len 1
john 0
len 0

Check if key exists

We can check if a key exists by using the second return value when accessing a key in a map.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func main() {
 m := map[string]int{
 "john": 66,
 }
 i, ok := m["john"] // Try changing the key
 if !ok {
 fmt.Println("The key does not exist in the map")
 }
 fmt.Println("i", i)
 fmt.Println("ok", ok)
}

Output:
i 66
ok true

Looping over elements

And range over all the elements:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package main

import "fmt"

func main() {
 m := map[string]int{
 "john": 66,
 "another": 50,
 }
 for key, value := range m {
 fmt.Println("key", key)
 fmt.Println("value", value)
 }
}

Output:
key another
value 50
key john
value 66

Docs: Interfaces

Mon, 01 Jan 0001 00:00:00 +0000

Basics

Interfaces are used to express general behaviour across multiple types. Interface types are defined as a set of method signatures. All types which implement this set of methods implement the defined interface.

As an example we define the interface Stringer:

type Stringer interface {
 String() string
}

All types that implement the method String() and return a string implement the Stringer interface. Types implicitly implement an interface if they implement the required methods. This is different to many other language where we have to explicitly specify that a certain type implements an inteface (e.g. in Java with implements).

In the following example User and Group implement the Stringer interface. The PrintAll function expects a slice of Stringers. This way we can pass users, groups and every other type which implements the Stringer interface to the PrintAll function. In the main function we then initialize a user and a group and put them both into a slice of Stringers which we then pass to the PrintAll function.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


package main

import "fmt"

// interface type Stringer
type Stringer interface {
 String() string
}

// concrete type User
type User struct {
 Username string
}

func (u *User) String() string {
 return u.Username
}

// concrete type Group
type Group struct {
 Groupname string
}

func (g *Group) String() string {
 return g.Groupname
}

// a function which takes a list of Stringers
func PrintAll(items []Stringer) {
 for _, item := range items {
 // the only thing we know about the items is that they have a method String()
 text := item.String()
 fmt.Println(text)
 }
}

func main() {
 user1 := &User{
 Username: "andrea",
 }

 group1 := &Group{
 Groupname: "admins",
 }

 myItems := []Stringer{user1, group1}

 PrintAll(myItems)
}

Output:
andrea
admins

Any (Empty Interface)

The interface any is an alias for the empty interface interface{}. This alias got introduced in Go 1.18. Before we just wrote interface{} instead.

As the name says the empty interface does not contain any method signatures. Hence all types implement the empty interface.

Note

Usually you should avoid using any, because then you have to check the types yourself in the code during runtime and the compiler no longer helps you during the compile time. We still mention it here because in rare cases it can be useful and it is used in a couple of places in the standard library.

Any is used by functions which can handle any or at least multiple types. An example for this is the Marshal function from the encoding/json package which serializes a type into its JSON representation.

Its function signature looks as follows:

func Marshal(v any) ([]byte, error)

It takes any type and returns the serialized data ([]byte) or an error (error) if something went wrong during the serialization.

Type Assertion 🌶️

With a type assertion we can obtain the underlying concrete type of an interface type during runtime. In the following example we have a variable of type Stringer. Stringer is an interface type. With type assertion we can check if the variable is a User. If the variable is a User then ok is true and the User is returned.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import "fmt"

type Stringer interface {
 String() string
}

type User struct {
 Username string
}

func (u *User) String() string {
 return u.Username
}

func main() {
 var myStringer Stringer = &User{
 Username: "simone",
 }

 // type assertion
 user, ok := myStringer.(*User)

 if ok {
 fmt.Println(user.Username)
 } else {
 fmt.Println("myStringer is not of type User")
 }
}

Output:
simone

Type Switch 🌶️

With a type switch we can check of which type a certain interface type is:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package main

import "fmt"

func printType(item any) {
 switch val := item.(type) {
 case int:
 fmt.Println("type is int")
 case []int:
 fmt.Printf("int list with length %d\n", len(val))
 default:
 fmt.Println("unexpected type")
 }
}

func main() {
 printType(1)
 printType([]int{1, 2, 3, 4})
 printType(true)
}

Output:
type is int
int list with length 4
unexpected type

Go Basics Training – Basics

Docs: Variables

Basics

Declaration

Zero values

Docs: Flow control

If Else

Switch

Loops

For - Classical

While equivalent

Docs: Functions

Basics

No Return Value

Multiple Return Values

Returning Errors

Function As Values

Docs: Pointers

Basics

Why Use Pointers

Docs: Structs

Basics

Declare Struct Type

Create Instance

Access Struct Fields

Structs As Function Arguments

Constructors

Methods

Nested Structs

Embedding

Docs: Slices

Basics

Slice of structs

Appending items

Loops

Links

Docs: Maps

Basics

Check if key exists

Looping over elements

Docs: Interfaces

Basics

Any (Empty Interface)

Note

Type Assertion 🌶️

Type Switch 🌶️