Go Notes

Learn Go - Introduction

From The Get Go

• Developed by Google
• Sits between low-level & high-level
• Produces code that runs fast and uses little memory
  • Has garbage collection
• Some object oriented features

Compiling Files

• To make a .go file into an executable we need to compile it via the go build command
  • E.g. go build greet.go
  • After this by doing an ls in the directory we can now see that we have an executable called greet

ls
greet     greet.go

• This can be executed via ./greet

Running Files

• We can directly run a file instead of the two step process shown above of compilation and then running
  • The go run command compiles the code and then runs it
  • But an executable won't be created in our directory
  • E.g. go run greet.go
• Useful for quick testing of code

Packages

• Projects can have multiple .go files organised into packages
  • Essentially like a directory
  • E.g. calculator program would have calculation .go files in calc package
    • I/O related go files in io package
• Simple example
  • 1st line below package main tells compiler which package file belongs to
    • It is package declaration
    • Specifying package main ensures program compiles into executable
  • 2nd line of code imports function from another package via import command
    • Notice that package name is in quotes

package main 

import "fmt" 

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

Main Function

• To define a function in Go use the func keyword
  • Followed by name of function E.g. main
  • After this we need a set of parentheses i.e. ()
  • Any code inside the function needs to be within set of curly braces i.e. {}
    • Also needs to be indented
  • E.g.

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

• Having a main function inside main.go is special to Go
  • Created executable when compiled
  • Also starts executing code in here as starting point
    • Same as python
• Defining a function doesn't call it
  • Same as python

Importing Multiple Packages

• There are two main ways to import multiple palcage
  • USe multiple import statements
  • Or use single statement with parentheses
    • E.g.

import (
  "package1"
  "package2"
)

• We can also give a package an alias
  • Then refer to this instead inside code
  • As we do in python using as keyword
  • E.g.

import (
  p1 "package1"
  "package2"
)

Comments

• There are two different types of comment in Go
  • Single-line using //
    • E.g.

// This entire line is ignored by the compiler
// fmt.Println("Does NOT print")
fmt.Println("This gets printed!") // This part gets ignored

• Block comments a.k.a multi-line using /* */
  • E.g.

/*
This is ignored.
This is also ignored. 
fmt.Println("This WON'T print!")
*/

Go Resources

• Golang includes go doc tool for viewing documentation about packages and their functions
  • E.g.

$ go doc fmt.Println
package fmt // import "fmt"

func Println(a ...interface{}) (n int, err error)
    Println formats using the default formats for its operands and writes to
    standard output. Spaces are always added between operands and a newline is
    appended. It returns the number of bytes written and any write error
    encountered.

Learn Go - Variables & Types

Literals

• Literals a.k.a values can be anything from number or text
  • Essentially unnamed things
    • i.e. not assigned to variables
• We can do normal arithmetic on integer literals
  • Or add strings together
  • But we can't multiply string and int like we can in python
    • i.e. print string x no. of times

Constants

• One type of named values
• Can't be updated while program running
  • Helps conveys intent of keeping consistent value
• We use const keyword to create constant
• E.g.

const funFact = "Hummingbirds' wings can beat up to 200 times a second."

fmt.Println("Did you know?")
fmt.Println(funFact)

• We must use camelCase or PascalCase for constants

Data Types

• Programming languages like Go store data as binary numbers in memory
• Go has 3 basic data types for numbers
  1. Integers - int
     • Can be positive or negative
     • E.g. 22 and -1500
  2. Floating-point - float
     • Numbers with a decimal point
     • Can also be positive or negative
     • E.g. 1458.2 and -1900.001
  3. Complex Numbers - complex
     • Can also be +ve or -ve
     • Used in 2D coordinates or calculation include sq roots
     • E.g. 3i and -14 - -.05i

Basic Numeric Types in Go

• There are 15 ways to describe a number in Go
  • 2 types for floating-point
  • 11 types for integer
  • 2 types for complex
• The different types dictate how much memory number takes to store
  • As well as how many binary digits it uses to store it
    • Less bits means fewer possible values i.e. min/max values
  • Better to use types with smaller range if possible
• Integers can be signed or unsigned
  • Unsigned can only be positive
    • Minimum value is 0
  • Signed can be either -ve or +ve
    • Max value lower than unsigned for same no. of bits vs unsigned
• Boolean type only uses 1 bit
• Numeric Data Types Table

• Floats and complex no. don't have max. or min. numbers
• Floats can be float32 or float64
  • Difference is how much data used to ensure value's precision

What is a Variable

• Variables in Go are defined using var keyword
  • They also need their type defined
  • E.g. var neighbourUp bool
• Should also be in camelCase
• Other examples
  • var lengthOfSong uint16 - Unsigned 16-bit integer
  • var songRating float32 - 32-bit float

Reading Go Errors

• When Go compiler raises error code cannot be turned into binary
  • Thus code can't be run
• An example of an error is when we define variable but don't use it
  • E.g. ./main.go:4:7: numberWheels declared and not used
    • Unused variables are waste of space

Assigning Variables

• After defining a variable we can assign it a value
  • E.g.

var ipAddress string
ipAddress = "192.168.1.2"

• We could also define and assign a value in one line
  • E.g. var kilometersToMars int32 = 62100000
• Strings can't have single quotes
  • USed for specific character called rune

Zero Values

• Variables of different types have default values
  • i.e. String defaults to "", int to 0 and boolean to false
  • E.g.

var classTime uint32
var averageGrade float32
var teacherName string
var isPassFail bool

fmt.Println(classTime) // Prints 0
fmt.Println(averageGrade) // Prints 0
fmt.Println(teacherName) // Doesn't print anything
fmt.Println(isPassFail) // Prints false

Inferring Values

• In Go we don't have to specify variable type if we use := operator
  • Called short decleration operator
  • We can use this if we know what variable should hold when creating it
• E.g.

nuclearMeltdownOccurring := true
radiumInGroundWater := 4.521 //Type float64
daysSinceLastWorkplaceCatastrophe := 0 //Type int32/int64
externalMessage := "Everything is normal. Keep calm and carry on."

• Notice we don't need to use var keyword
• The long way to do the above is:

var nuclearMeltdownOccurring = true
var radiumInGroundWater = 4.521
var daysSinceLastWorkplaceCatastrophe = 0
var externalMessage = "Everything is normal. Keep calm and carry on."

Default int Type

• We can assign an integer uint or int type
• If computer architecture is 32-bit it will use int32/uint32
  • If 64-bit then int64/uint64
• Usually recommended to use either uint or int
  • Instead of specifying no. of bits
  • E.g.

var timesWeWereFooled int
var foolishGamesPlayed uint

• When we use value inferring with integers it defaults to int
  • E.g. consolationPrizes := 2

Updating Variables

• As with Python we can update variables in Go
  • In below e.g. basketTotal var defaults to 0
    • Wouldn't be the case in Python

var basketTotal float64
carrotPrice := 0.75

basketTotal = basketTotal + carrotPrice
fmt.Println(basketTotal) // Prints: 0.75

• Same as Python we can also use += above instead
  • Also works on strings
  • Others operators are: *=, /= and -=

Multiple Variable Declaration

• We can declare multiple variables in single line
  • E.g.

var part1, part2 string
part1 = "To be..."
part2 = "Not to be..."

• Same goes for inferring also
  • E.g. quote, fact := "Bears, Beets, Battlestar Galactica", true

Learn Go: FMT Package

The fmt Package

• fmt is one of Go's core packages
  • Also has utilities that help us format data
    • Apart from printing things
• Other supported methods
  • fmt.Print()
  • fmt.Printf()
  • The below format but doesn't print anything to the console
  • fmt.Sprint()
  • fmt.Sprintln()
  • fmt.Sprintf()
  • To get user input
    • • fmt.Scan()

The Print Method

• The fmt.Println() method does some formatting for us by default
  • It adds a space to the arguments inside it and adds line break at the end
• Sometimes we may not want this behaviour
  • i.e don't want the extra space or the line break
• E.g.

fmt.Print("The answer is", ": ")
fmt.Print("12")
// Prints: The answer is: 12

The Printf Method

• The fmt.Printf() method allows us to do string interpolation
  • Like f-strings
• Example
  • %v part is called verb
    • Specific letter after % tells it what exactly to put in placeholder

selection1 := "soup"
selection2 := "salad"
fmt.Printf("Do I want %v or %v?", selection1, selection2)
// Prints: Do I want soup or salad?

Different Verbs

• Another verb is %T which prints out type of 2nd argument
  • E.g.

specialNum := 42
fmt.Printf("This value's type is %T.", specialNum)
// Prints: This value's type is int.

quote := "To do or not to do"
fmt.Printf("This value's type is %T.", quote)
// Prints: This value's type is string.

• The %d verb prints out a number in string format
  • E.g.

votingAge := 18
fmt.Printf("You must be %d years old to vote.", votingAge)
// Prints: You must be 18 years old to vote. 

• The %f verb to print out a float in string format
  • E.g.

gpa := 3.8
fmt.Printf("You're averaging: %f.", gpa)
// Prints: You're averaging 3.800000.

• We can also control number of decimals in float
  • E.g.

gpa := 3.8
fmt.Printf("You're averaging: %.2f.", gpa)
// Prints: You're averaging 3.80.

Sprint and Sprintln

• These methods allow us to format strings without printing them
  • E.g.

grade := "100"
compliment := "Great job!"
teacherSays := fmt.Sprint("You scored a ", grade, " on the test! ", compliment)

fmt.Print(teacherSays)
// Prints: You scored a 100 on the test! Great job!

• As before Sprintln adds spacing and a new line
  • E.g.

quote = fmt.Sprintln("Look ma,", "no spaces!")
fmt.Print(quote) // Prints Look ma, no spaces!

Sprintf Method

• Method a bit like using python f-string without print statement
  • Let's us do interpolation
• Uses same verbs as Printf

correctAns := "A"
answer := fmt.Sprintf("And the correct answer is… %v!", correctAns)

fmt.Print(answer) // Prints: And the correct answer is… A!

Getting User Input

• We can use the fmt.Scan method to get input from user
  • E.g. below would take in single word from user
    • If we entered 2 words separated by space only 1st one taken

fmt.Println("How are you doing?") 

var response string 
fmt.Scan(&response)

fmt.Printf("I'm %v.", response) 

• Below example takes 2 arguments i.e. 2 words

fmt.Println("How are you doing?") 

var response1 string 
var response2 string 
fmt.Scan(&response1)
fmt.Scan(&response2)

fmt.Printf("I'm %v %v", response1, response2)

• The & character used references addresses as fmt.Scan() expects these
  • Without it the program will not actually ask for any input

Conditionals

If Statement

• Our condition can be within parenthesis but not mandatory
• Code to be executed if condition is true needs to be within curly braces
  • No colon needed like Python
• Booleans in Go are all lowercase. E.g. true
• E.g.

alarmRinging := true
if alarmRinging {
  fmt.Println("Turn off the alarm!!") 
}

The Else Statement

• Else block will also need to have it's code in curly braces
  • E.g.

isHungry := false
if isHungry {
  fmt.Println("Eat the cookie") 
} else {
  fmt.Println("Step away from the cookie...")
}

Comparison Operators

• Comparison operators work in the exact same way as Python

Logical Operators

• Different to Python
  • Not is !
  • And is &&
  • Or is ||
• E.g.

if storeLights == "on" && doorsOpen {
  fmt.Println("You can enter the store!")
} 

Not Operator

• Essentially reverses value of a boolean
  • E.g.

bored := true
fmt.Println(!bored) // Prints false

tired := false;
fmt.Println(!tired) // Prints true

• We can also add them to if statements
  • E.g.

if !readyToGo {
		fmt.Println("Start the car!")
}

Else if Statement

• Instead of elif in Python in Go we use else if
  • E.g.

position := 2

if position == 1 {
  fmt.Println("You won the gold!")
} else if position == 2 {
  fmt.Println("You got the silver medal.")
} else if position == 3 {
  fmt.Println("Great job on bronze.")
} else {
  fmt.Println("Sorry, better luck next time?")
}

Switch Statement

• Instead of the verbosity of writing multiple else if statements we can use switch and match
• switch is followed by variable the conditional is looking at
• case is followed by value it should be equal to and colon
  • Then code that should be run for condition is indented below
  • Can also use comparsion operators
• Finally the default keyword is used at the end like an else
• E.g.
  • Using else if

clothingChoice := "sweater"

if clothingChoice == "shirt" {
  fmt.Println("We have shirts in S and M only.")
} else if clothingChoice == "polos" {
  fmt.Println("We have polos in M, L, and XL.")
} else if clothingChoice == "sweater" {
  fmt.Println("We have sweaters in S, M, L, and XL.")
} else {
  fmt.Println("Sorry, we don't carry that.")
}

• Same example now using switch

clothingChoice := "sweater"

switch clothingChoice {
case "shirt":
  fmt.Println("We have shirts in S and M only.")
case "polos":
  fmt.Println("We have polos in M, L, and XL.")
case "sweater":
  fmt.Println("We have sweaters in S, M, L, and XL.")
case "jackets":
  fmt.Println("We have jackets in all sizes.")
default:
  fmt.Println("Sorry, we don't carry that")
}
// Prints: We have sweaters in S, M, L, and XL.

Scoped Short Decleration Statement

• We can declare variables within an if or switch statement
  • Done using := straight after if keyword
  • But before the comparison
  • Separated by ;
  • E.g.

x := 8
y := 9
if product := x * y; product > 60 {
  fmt.Println(product, "  is greater than 60")
}

• E.g. below shows how to do it within switch statement

switch season := "summer" ; season {
case "summer":
  fmt.Println("Go out and enjoy the sun!")
}

• Variable defined like this are only valid within the block
  • i.e. Trying to use these after outside of the block will throw an error

Randomising

• Go has a math/rand library which can generate random numbers for us
  • E.g. of usage
    • below should print a random number from 0 to 99 but it will always print 81

import (
  "math/rand"
  "fmt"
)

func main() {
  fmt.Println(rand.Intn(100))
}

Seeding

• The reason the above code did not give us random number was due to how Go chooses starting no.
  • i.e. starting point for generating random number
  • Known as seed number which defaults to 1
• To actually get random number we need to pass in unique seed number
  • To get seed no. we use rand.Seed() method
  • One way to do this is to use the time via time library
    • As it's always different
    • E.g.

package main

import (
  "fmt"
  "math/rand"
  "time"
)

func main() {
  // Gives us time difference since 1 Jan 1970 UTC in us thus different seed no.
  rand.Seed(time.Now().UnixNano())
  fmt.Println(rand.Intn(100))
}

• Essentially this line will give us random number: rand.seed(time.Now().UnixNano())

Functions

What is a function

• In Go we use func keyword to define a function
  • Type hints are mandatory unlike python
  • E.g. below shows function with input and output being ints
    • Code also needs to be in curly braces

func doubleNum(num int) int {
  return num * 2
}

• main function doesn't have to be called as compiler already knows to do it
  • Unlike Python
• A function is called in the exact same way as python
  • E.g. fmt.Println(doubleNum(x)) // Prints: 10

Scope

• There are 3 scopes for variables inside Go as with Python
  • Global
  • Within function
  • Within main function

Returning Values from Functions

• Works in similar way to Python

Using Function Parameters

• As with python we can call a function with some arguments
  • Then these parameters are used within the function
• If multiple parameters have the same type we don't need to specify each time
  • E.g.

func multiplier(x, y int32) int32 {
  return x * y
}

Returning Multiple Values

• As in Python we can also return multiple values in a function
  • We can then unpack them in exactly the same way also
    • As well as being able to use special variable _
  • E.g.

package main

import "fmt"

func getLengthOfCentralPark() (int32, string) {
	var lengthInBlocks int32
	lengthInBlocks = 51
	unit := "m"
	return lengthInBlocks, unit
}

func main() {
	len, unit := getLengthOfCentralPark()
	fmt.Print(len, unit)
}

Deferring Resolution

• We can use the defer keyword to do something at the end of a function call
  • Usually call another function
• Useful if we have multiple return statements in code
  • As any code aftrer a return statement is not run
• Feature can be used logging and writing to file etc.
  • Or doing things like disconnecting from DB aftrer we run a query
• Typically added at the top of a function definition
• E.g.

func calculateTaxes(revenue, deductions, credits float64) float64 {
  defer fmt.Println("Taxes Calculated!")
  taxRate := .06143
  fmt.Println("Calculating Taxes")

  if deductions == 0 || credits == 0 {
    return revenue * taxRate
  }
  

  taxValue := (revenue - (deductions * credits)) * taxRate
  if taxValue >= 0 {
    return taxValue
  } else {
    return 0
  }
}

// Output
Calculating Taxes
Taxes Calculated!

Addresses & Pointers

The Point of Pointers and Addresses

• Go is pass-by-value language
  • Functions are passed value of argument
    • Not argument itself
    • Means changes that happen in function stay within function
• Analogy of a teacher with a worksheet
  • She has original copy but hands copies to students
  • Student's don't write/change the original
• We can change values from different scopes using below:
  • Addresses
  • Pointers
  • Dereferencing

Addresses

• When we declare a variable in Go the computer sets aside space in memory to store value
  • Called address and is unique numerical value
• When we use variable we get value stored at address
  • Use the & operator to print variable' address
    • Followed by name of variable
    • Gives us value in Hex

x := "My very first address"
fmt.Println(&x) // Prints 0x414020

Pointers

• Pointers are variables that store addresses
  • * operator used to signify variable stores address
  • E.g. var pointerForInt *int
    • We specify address of variable is holding an int
• Full example

var pointerForInt *int

minutes := 525600

pointerForInt = &minutes

fmt.Println(pointerForInt) // Prints 0xc000018038

• Another way we can declare a pointer is via inferring
  • E.g.

minutes := 55

pointerForInt := &minutes

Dereferencing

• We can use this if we want address to store different value
  • i.e. change what's stored there
• A.k.a indirecting
• We still need to use * operator
  • E.g.

lyrics := "Moments so dear" 
pointerForStr := &lyrics
// use dereferencing to point to address in memory and assign new value
*pointerForStr = "Journeys to plan" 

fmt.Println(lyrics) // Prints: Journeys to plan

Changing Values in Different Scopes

• In Go when we call function with value as input we don't pass actual address of variable
  • But just it's value
• We have below e.g. where x does not change

func addHundred(num int) {
  num += 100
}

func main() {
  x := 1
  addHundred(x)
  fmt.Println(x) // Prints 1
}

• To make sure x changes we would have to do this
  • addHundred func now takes in pointer as parameter
  • We then reference it and give it new value in memory address
  • In main func we also need to give pointer using address via & operator

func addHundred (numPtr *int) {
  *numPtr += 100
}

func main() {
  x := 1
  addHundred(&x)
  fmt.Println(x) // Prints 101
}

Loops

Classic For Loop

• A for loop in Go has 3 components
  • 1st part is where we define starting value for loop variable
  • 2nd is the condition that needs to be true
  • 3rd is what to do after each iteration
    • i.e. increment loop variable
• E.g.

for number := 0; number < 5; number++ {
  fmt.Print(number, " ")
}
// Output: 0 1 2 3 4

• For loop in Go is unlike for loop in Python

For as a While Loop

• Sometimes we don't know how many iterations of loop we need
  • Here we use indefinite loops
    • Repeat whilst condition is true
• Go uses for statement for these types of loop too
  • But there are 2 main differences
    1. Loop variable needs to defined outside of block
    2. Update to loop variable after each iteration needs to be within block
       • Unlike in definite loop
• E.g.
  • Output of below and above example are the same

number := 0 // Initialize a variable to be used inside the loop
for number < 5 {
  fmt.Println(number)
  number++ // Update the variable being used
}

Infinite Loop

• These are usually dangerous but can also be useful
  • In case of something like web server that needs to run always
    • But we can break out of the loop
• E.g.

for {
  // Loop body logic
  // This repeats forever
}
// This is never reached

Break and Continue

• As with python we can use these two keywords to break out of a loop
  • Or current iteration
• Example of break keyword

// Init slice of strings - dynamically sized flexible view into array elements
animals := []string{"Cat", "Dog", "Fish", "Turtle"}
for index := 0; index < len(animals); index++ {
  if animals[index] == "Dog" {
    fmt.Println("Found the perfect animal!")
    break // Stop searching the array
  }
}

• Example of continue keyword

jellybeans := []string{"green", "blue", "yellow", "red", "green", "yellow", "red"}
for index := 0; index < len(jellybeans); index++ {
  if jellybeans[index] == "green" {
    continue
  }
  fmt.Println("You ate the", jellybeans[index], "jellybean!")
}

Looping and Arrays

• We can use the range keyword with maps and arrays
  • To loop through their elements
  • E.g. below shows usage
    • range letters gives us 2 things back always
      • array index and actual element
      • So below syntax needed

letters := []string{"A", "B", "C", "D"}
for index, value := range letters {
  fmt.Println("Index:", index, "Value:", value)
}

• Output:

Index: 0 Value: A
Index: 1 Value: B
Index: 2 Value: C
Index: 3 Value: D

• For maps the syntax is the same but range gives key, value instead
  • E.g.

addressBook := map[string]string{
  "John": "12 Main St",
  "Janet": "56 Pleasant St",
  "Jordan": "88 Liberty Ln",
}
for key, value := range addressBook {
  fmt.Println("Name:", key, "Address:", value)
}

• Output:

Name: John Address: 12 Main St
Name: Janet Address: 56 Pleasant St
Name: Jordan Address: 88 Liberty Ln

Arrays & Slices

Intro to Arrays

• Fixed size collection of data elements of same type
  • Unlike python where they can be mixed and variable size
  • We can still use indexing to access them

Array Creation

• Before using an array we need to declare and name it
• When a variable is declared in Go compilor finds space in memory for it
  • Associates name with variable too
  • Issue is that compilor needs to find enough space for several occurances of data type
  • Thus we need to provide no. of elements
• Once declared the no. of elements can't be changed
  • Workaround is to declare new array
• Array's can be created with inital set of elements
  • But not mandatory
  • E.g. below defines empty array with 4 elements of type int

var playerScores [4]int
fmt.Println(playerScores)
// [0 0 0 0]

Array Creation with Elements

• To give an array elements at creation we need to use square brackets {}
  • E.g. triangleSides := [3]int{15, 26, 30}
• We could also make the compiler dynamically determine array length
  • Using ellipsis syntax i.e. ...
  • E.g. triangleAngles := [...]int{30, 60, 90}

Access Array Values with Indices

• As with Python we can access individual elements via it's index
  • But unlike Python we can't use a negative index
    • Workaround is to use length := len() and use length-1 index
      • E.g. fmt.Println("Last", slice[length-1])
      • Or slice[len(slice)-1] = newName

students = [3]string{"Jill", "Fred", "Sasha"}
// Access the first element of the array
fmt.Println(students[0])
// Output: Jill
// Access the third element of the array
fmt.Println(students[2])
// Output: Sasha
// Store the second element into a variable
secondStudent := students[1]
// Print it
fmt.Println(secondStudent)
// Output: Fred

Modifying Array Values

• As with Python we can change array values via index
  • E.g.

myArray := [4]int{10, 24, 5, 47}
myArray[2] = 33

Intro to Slices

• Slices are similar type to arrays but can change size
• There are different ways to create slices
  • E.g.

// Each of the following creates an empty slice
var numberSlice []int
stringSlice := []string{}

// The following creates a slice with elements
names := []string{"Kathryn", "Martin", "Sasha", "Steven"}

• We can also create a slice based on existing array
• Updating an element in a slice also updates the original array
• E.g.

array := [5]int{2, 5, 7, 1, 3}
// This is a slice of the whole array
sliceVersion := array[:]
fmt.Println(sliceVersion)
// prints
// [2 5 7 1 3]

// Change slide element
sliceVersion[1] = 6
fmt.Println(array)
// prints - original array also changed
// [2 6 7 1 3]

• As with python we can use slicing to get sub-set of array
  • E.g.

partialSlice := array[2:5]
fmt.Println(partialSlice)
// [7 1 3]

• Unlike arrays we don't need to specify no. of elements
• We can access elements normally via indexes
  • E.g.

var names = []string{"Kathryn", "Martin", "Sasha", "Steven"}
fmt.Println(names[1])
// Martin
names[3] = "Bishop"
fmt.Println(names[3])
// Bishop

Length and Capacity

• As with python we can use the len() function get the length of array/slice
  • E.g.

favoriteThings := [2]string{"Raindrops on Roses", "Whiskers on Kittens"}
fmt.Println(len(favoriteThings))
// 2

• Slices also have concept of capacity as they are re-sizable
  • Defines as max no. of elements it can hold before needing to re-size
  • We use cap() function to figure out capacity
  • E.g. below shows how capacity of slice doubles when we try to append element to it
    • Slice is already at full capacity

slice := []string{"Fido", "Fifi", "FruFru"}
// The slice begins at length 3 and capacity 3
fmt.Println(slice, len(slice), cap(slice))
// [Fido Fifi FruFru] 3 3
slice = append(slice, "FroFro")
// After appending an element when the slice is at capacity
// The slice will double in capacity, but increase its length by 1
fmt.Println(slice, len(slice), cap(slice))
// [Fido Fifi FruFru FroFro] 4 6

• Slices can still have elements added if they are at full capacity

Append to Slices

• We can use the append() function to add elements to slices
  • Syntax is slice name then element to add
  • We need to re-assign slice for it to work
  • Slice re-sizes automatically
  • E.g.

books := []string{"Tom Sawyer", "Of Mice and Men"}
books = append(books, "Frankenstein")
books = append(books, "Dracula")
fmt.Println(books)

Arrays and Slices in Functions

• To pass in an array into a function as parameter we give the name, [] with no. of elements and element data type
  • For slices we don't need no. of elements just []
  • E.g.

func printFirstLastArray(array [4]int) {
    fmt.Println("First", array[0])
    fmt.Println("Last", array[3])
}

func printFirstLastSlice(slice []int) {
    length := len(slice)
    if (length > 0) {
        fmt.Println("First", slice[0])
        fmt.Println("Last", slice[length-1])
    }
}

• Modifying an array parameter only does so locally within function

  • As Go in pass-by-value language

  • E.g.

// Changes to the array will only be local to the function
func changeFirst(array [4]int, value int) {
    array[0] = value
}

• Other option is to return the array within function
• If we want to retain changes made use a slice
  • E.g.

// Changes to the slice parameter will be permanent
func changeFirst(slice []int, value int) {
    if (len(slice) > 0) {
        slice[0] = value
    }
}

• Slices act as pointers

Go Maps

Intro to Maps

• Essentially a python dictionary
  • But we need to specify type of key and value
• Syntax is map[key_type]value_type
  • E.g.

package main
import "fmt"

func main() {
	// Create a simple contact list.
	contacts := map[string]int{
		"Joe":    2126778723,
		"Angela": 4089978763,
		"Shawn":  3143776876,
		"Terell": 5026754531,
	}
	// Print out all the contacts
	fmt.Println(contacts)
}
// Prints: map[Angela:4089978763 Joe:2126778723 Shawn:3143776876 Terell:5026754531]

• We access value's the same way we do in python

Map Creation

• To create an empty map we can use the make() function
  • Passing in map definition
  • E.g. prices := make(map[string]float32)
• To create a map with values already we don't need to use make()

contacts := map[string]int{
    "Joe":    2126778723,
    "Angela": 4089978763,
    "Shawn":  3143776876,
    "Terell": 5026754531,
}

Accessing Values in Maps

• We access values in a map the same way we do with Python dictionaries
  • But if the key doesn't exist we're returned default value for type
  • We can also get another value which is boolean telling us if key's in the map
  • E.g. below unpacks map key where status var tells us if key is in map or not
    • Customer gives us actualy value

customer,status := customers["billy"]

if status {
  fmt.Println("we found the customer")
} else {
  fmt.Println("no such customer!")
}

Adding and Modifying

• We can add a new key: value pair to a map using same syntax as Python
  • Updating an existing key's value is done in the same way also

Removing

• To remove a key from a map we need to use the delete() function
  • Syntax: delete(mapName, keyName)
    • E.g. delete(contacts, "Gary")
• Trying to delete a key that doesn't exist has no effect
  • i.e. no error or exception thrown unlike Python

Extra

• To format go code use gofmt -w fileName
  • E.g. gofmt -w test.go

Structs in Go

Introduction

• Somewhat similar to a Python class where we can have different types together

Defining a Struct

• We define a struct via the type keyword
  • Syntax: type StructName Struct
  • Once defines we can then use it as a type in our code
  • E.g.

type Point struct {
  x int
  y int
}
var firstPoint Point

Creating Instance of a Struct

• To use a struct defined we create instance of it
  • E.g. p1 := Point{x: 10, y: 12}
• We can omit single or multiple fields when creating instances
  • Default value will be used for type

p1 := Point{}
// x and y will be set to 0

• Another option is to omit the label names i.e. x and y
  • But this way providing values for all fields is mandatory
  • E.g.

p1 := Point{10, 12}
// Same as var p1 = Point{10, 12}

Accessing and Modifying Struct Variables

• Once we've defining and created struct instance we can access fields
  • By using dot notation similar to how we access Python class attributrs
  • E.g.

john := Student{"John", "Smith", 14, 9}
fmt.Println(john.firstName)

• We can change a field's value within a struct
  • E.g. john.age = 15

Functions that Access Struct

• We can use functions to do operations on structs
  • E.g. struct representing shape has functions to compute area/perimeter
• Example below is struct representing rectangle

type Rectangle struct {
  length float32
  width  float32
}

• We can then have a function that computes area of rectangle
  • (rectangle Rectangle) means func belong to Rectangle struct
  • area() is name of function

func (rectangle Rectangle) area() float32 {
  return rectangle.length * rectangle.width
}
rect := Rectangle{1, 2}
rect.area()

• Functions associated with struct are written outside it
  • Unlike Python classes and methods
• Defining func in this was we only pass in copy of rectangle
  • Function can't change value of field
  • If we wanted func to modify struct field's value we need to pass pointer into struct

Pointers to a Struct

• Without a pointer only copies of variables are passed into function
  • Therefore using one allows us to modify original values
• Example below uses Employee struct

type Employee struct {
  firstName string
  lastName string
  age int
  title string
}

func main() {
  steve := Employee{"Steve", "Stevens", 34, "Junior Manager"}
  // Point to instance by getting address
  pointerToSteve := &steve
}

• There are two ways we can use pointer to change steve field values
  • 1. (*pointerToSteve).firstName
  • 2. Simpler way: `pointerToSteve.firstName
• Below e.g. show's us another way we can modify a struct's field within a func

func (rectangle *Rectangle) modify(newLength float32){
  rectangle.length = newLength
}

• In above function rectangle is pointer
  • Dereferenced without need for &

Arrays of Structs

• When we have multiple structs with same type we can put them into array
  • E.g. points := []Point{{1, 1}, {7, 27}, {12, 7}, {9, 25}}
  • If each point is set to anamed variable we could also do this:

a = {1, 1}
b = {7, 27}
c = {12, 7}
d = {9, 25}

points := []Point{a, b, c, d}
fmt.Println(points[0]) // Output will be {1, 1}

• We can also access the struct's values like this
  • E.g.

points := []Point{{1, 1}, {7, 27}, {12, 7}, {9, 25}}

points[1].x = 8
points[1].y = 16

fmt.Println(points[1]) // Output will be {8, 16}

Nested Structs

• We can have fields in a struct that reference other structs
  • E.g.

type Name struct{
  firstName string
  lastName string
}

type Employee struct{
  name Name // references Name struct above
  age int
  title string
}
// Create instance of employee
carl := Employee{Name{"Carl", "Carlson"}, 32, "Engineer"}
fmt.Println(carl.name.lastName) // Output will be "Carlson"

• We could access the firstName and lastName fields directly from Employee struct
  • But we'd have to define struct like this with anonymous field

type Employee struct{
  Name
  age int
  title string
}

• Here we could now do this: fmt.Println(carl.firstName) instead of the above
• But we couldn't have 2 anonymous fields of the same type
  • i.e. of Name type

Extra Notes

PacketCoders

• Golang doesn't have package manager like Python's PyPi
  • URL usually used e.g. go mod init github.com/suhaibasaeed/Go/codecademy/code
    • Creates a go.mod file
      • E.g below shows how file first looks
        • If we use 3rd party modules it will appear here
          • go.sum file would also be here in this case

module github.com/suhaibasaeed/Go/codecademy/code

go 1.21.4

• The go mod tidy command installs all imported dependencies
  • Creating go.sum for us
• Another way to install dependencies is via go get command
  • E.g. go get github.com/howeyc/gopass
• The go run . command compiles everythign in current dir
• Best practice to put compiled binaries from go build command in bin directory
  • Then put this into .gitignore
  • E.g. command go build -o ./bin/myapp main.go
• Go built in formatter works via go fmt command