Getting Started with Go 👨🏽‍💻

What is Go?

• Go is a compiled programming language, created by Google. It is known for being an alternative to C/C++, with an more readable syntax.

Hello World

• Go needs the main-function. It gets executed when running the programm. A unique package name must be provided, there must be one main package.

package main

import "fmt"

func main() {
  fmt.Println("Hello World!")
}

Execute & Build

• The build-file, which can be executed without having Go installed, depends on the OS. On Windows, it will be an .exe.

go run app.go  // run the code in dev mode
go build app.go // compiling
./app.go        // executing the build-file

Variables

What is special about Variables in Go?

• In Go, there can no undefined or null values occur, when declaring variables.
• There is no need to declare a variable with a data type.
• We can declare multiple variables at once.
• There is a long way, providing the datatype when declaring, and a shorthand, using type inference for declaring.
• We can use var and const. Last one means constant, so changing the value of such a variable, will break the program.
  A constant must have an initial value.

Declaring Variables

• Using type inference, Go can guess the correct datatype for our variable. We can declare multiple variables at once.

// Providing the value later
var name string 
name = "Max"

// Providing the value fist
var name string = "Max"

// Using type inference
name := "Max"
var width, height float32 = 2.5, 6.1
// or: 
width, height := 2.5, 6.1
fmt.Println(width) 	// 2.5
fmt.Println(height)	// 6.1

Default value

• When providing a datatype for the variable when declaring, but leaving out the value, a default value will be applied.

var firstVar bool
fmt.Println(firstVar) // false

var firstVar string
fmt.Println(firstVar) // ""

var firstVar float64
fmt.Println(firstVar) // 0
                      
var firstVar int 
fmt.Println(firstVar) // 0

Functions in Go

Function & Return

• The datatype stands after the variable name. The last ‘int’ is the datatype of the return-value.

func add(x int, y int) int {
	return x + y
}

func main() {
	fmt.Println(add(5, 5))  // 10
}

Shorting the datatypes

• If both parameters have the same data type, we can use a shortcut.

func add(x, y int) int {
	return x + y
}

Multiple Returns

• A function in Go can return multiple things.

func person(name string, age int) (string, int) {
	return name, age + 1
}

func main() {
	name, age := person("max", 22)
	fmt.Println(name, age)
	// max 23
}

Arrays

Basic Array

• Arrays can only hold one type of data. The first element always has the index of 0. They have a fixed size. Like variables in Go, they hold default values.

var ages [5]int 
fmt.Println(ages)
// [0 0 0 0 0]

Adding some values to it

var ages [5]int
ages[0] = 21
ages[1] = 23
fmt.Println(ages)
// [21 23 0 0 0]
// the better way:
ages := [5]int{23, 21, 19, 23, 24}
fmt.Println(ages)
// [23 21 19 23 24]

Slices

• Since arrays have a fixed number of elements, this is problem when we want to add something. By leaving out the number of elements, we initialize a slice.

ages := []int{23, 21, 19, 23, 24}
ages = append(ages, 27)
// append does not edit the existing slice. 
// It returns a new one.
fmt.Println(ages)
// [23 21 19 23 24 27]

Looping through an Array

ages := [3]int{23, 21, 19}
for index, value :=range ages {
    fmt.Println(index, value)
    // 0 23
    // 1 21
    // 2 19
}

Conditionals

If-Else

• There are now brackets in the syntax.

if 5 > 3 {
    fmt.Println("5 > 3")
} else {
    fmt.Println("3 > 5")
}

Else-if

• Else-If provides another condition, and gets executed if the condition is true, and if is not getting executed.

if 5 > 5 {
    fmt.Println("5 > 3")
} else if 5 >= 5 {
    fmt.Println("Greater / equal")
} else {
    fmt.Println("3 > 5")
}

Variables in if-else

• We can declare a variable within the syntax of an if-statement.

if age := 9; age < 18 {
    fmt.Print("Not grown up")
 }

For Loop

Which Loops exist?

• In Go, there is only the for-loop available. But it can be used as while for example, as you can see in the examples.

for-loop

• No () arround the content of the loop.

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

“While”-Loop in Go

for i := 0; i < 5; {
    fmt.Println(i)
    // endless prints
}

Pointers

Using a Pointe

• The syntax with the ‘&’ returns the memory address of the variable. Therefore, a Pointer holds a memory address.

func main() {
    var age = 24
    var agePointer = &age
	fmt.Println(agePointer)
	// for example '0xc000016078'
}

Getting the value behind the Pointer

• We can use the ‘*’ syntax to read the value, saved in the memory with the memory address, the pointer is holding.

var age = 24
var agePointer = &age
fmt.Println(*agePointer) // 24

Changing values with Pointers

• Not only can we read out values from the memory, we can also change it through pointers.

var age = 24
var agePointer = &age
*agePointer++
fmt.Println(*agePointer) // 25

Map & Struct

Basic Struct

type person struct {
	name string
	age int
}
func main() {
	personMax := person{name: "Max", age: 21}
	fmt.Println(personMax) // { Max 21}
	fmt.Println(personMax.name) // Max
}

Basic Map

• In the [] stands the type of the key, follwing is the type of the value.

people := make(map[string]int)
people["Max"] = 23
people["Tom"] = 19

fmt.Println(people["Max"])

Looping through a Map

people := make(map[string]int)
people["Max"] = 23
people["Tom"] = 19

for key, value := range people {
    fmt.Println(key, value)
    // Max 23
    // Tom 19
}```

**_Happy Coding!_** 👽