Alex

Matt Holiday Go Class (YouTube)

Notes from learning the fundamentals of the Go programming language from this amazing tutorial. It is a fantastic video tutorial on YouTube that explains Go concepts from the ground up and offers some great insight into the language design

Notes

Variables are defined with the var keyword or the shorthand := (only inside of functions / methods to simplify parsing!).
```
var a int
// or
a := 2 // in functions or methods
```
Fun Printf snippet - %d %[1]v will reuse the first passed in argument (e.g. if we want to print a single variable twice in a Printf, you’d normally do fmt.Printf("%d %d", a, a), but with this you just need to do fmt.Printf("%d %[1]v", a) and that parameter a will be reused)

Only numbers, strings or booleans can be constants

const(
  a = 1
  b = 3 * 100
  s = "hello"
)

Strings

byte is a synonym for uint8
rune is a synonym for int32 for characters
string is an immutable sequence of “characters”
- Logically a sequence of unicode runes
- Physically a sequence of bytes (UTF-8 encoding)
We can do raw strings with backticks (they don’t evaluate escape characters such an \n)
```
`string with "quotes"`
```
IMPORTANT: The length of a string is the number of UTF-8 bytes required to encode it, NOT THE NUMBER OF LOGICAL CHARACTERS
Internally strings consist of a length (remember that they are immutable) and a pointer to the memory where the string is stored. Since the descriptor contains a length, no null byte termination is needed (as is the case in C)
Strings are passed by reference
The strings package contains useful string functions

Arrays, Slices and Maps

Arrays have fixed size, slices are variable size
Slices have a backing array to store the data; slice descriptors (not an official thing - just used to denote the underlying logic of this data) have a length (how many things in the slice), a capacity (the capacity of the underlying array) and a pointer to the underlying array
Slices are passed by reference, but you can modify them unlike strings
- Arrays are passed by value
Arrays are also comparable with ==, slices are obviously not. Arrays can be used as map keys, slices cannot
Slices have copy and append helper operators
Arrays are used almost as pseudo constants

You can read from a nil map, but can’t insert (will panic)

var m map[string]int // nil map (reading any key will return nil)
_m = make(map[string]int) // empty non-nil map