$ go version
go version go1.23.5 darwin/arm64

$ go run -h
usage: go run [build flags] [-exec xprog] package [arguments...]
Run 'go help run' for details.

$ git clone https://github.com/nathancastelein/go-course-introduction.git
Cloning into 'go-course-introduction'...
remote: Enumerating objects: 8, done.
remote: Counting objects: 100% (8/8), done.
remote: Compressing objects: 100% (5/5), done.
remote: Total 8 (delta 0), reused 5 (delta 0), pack-reused 0
Receiving objects: 100% (8/8), done.

$ cd go-course-introduction

$ go run hello/main.go 
Hello there wonderful people!

package main

import "fmt"

func main() {
	fmt.Println("Hello there wonderful people!")
}

$ go help
Go is a tool for managing Go source code.

Usage:

        go <command> [arguments]

The commands are:

        bug         start a bug report
        build       compile packages and dependencies
        clean       remove object files and cached files
        doc         show documentation for package or symbol
        env         print Go environment information
        fix         update packages to use new APIs
        fmt         gofmt (reformat) package sources
        generate    generate Go files by processing source
        get         add dependencies to current module and install them
        install     compile and install packages and dependencies
        list        list packages or modules
 ...

$ cd hello
$ go run main.go 
Hello there wonderful people!
$ go run .  
Hello there wonderful people!

$ cd ../syntax
$ go run .
package github.com/nathancastelein/go-course-introduction/syntax is not a main package

➜  hello git:(main) ✗ ls
main.go
➜  hello git:(main) ✗ go build
➜  hello git:(main) ✗ ls
hello   main.go
➜  hello git:(main) ✗ ./hello 
Hello there wonderful people!

➜  hello git:(main) ✗ go install
➜  hello git:(main) ✗ which hello 
/Users/nathan/go/bin/hello
➜  hello git:(main) ✗ hello
Hello there wonderful people!
➜  hello git:(main) ✗ ls
main.go

package main

import "fmt"

func main() {
	fmt.Println("I'm using a useless semicolon!");
		fmt.Println("I'm badly indented!")
fmt.Println("Me too!")
}

package main

import "fmt"

func main() {
	fmt.Println("I'm using a useless semicolon!")
	fmt.Println("I'm badly indented!")
	fmt.Println("Me too!")
}

package main

import "fmt"

func main() {
	fmt.Println("I'm using a useless semicolon!");
		fmt.Println("I'm badly indented!")
fmt.Println("Me too!")
}

➜  fmt ✗ ls *_test.go
errors_test.go             export_test.go             gostringer_example_test.go state_test.go              stringer_test.go			example_test.go            fmt_test.go                scan_test.go               stringer_example_test.go

➜  fmt ✗ go test .
ok      fmt     0.452s

package main

import "fmt"

func main() {
	fmt.Println("Hello there wonderful people!")
}

package main

import (
	"fmt"
    "github.com/google/uuid"
)

func main() {
	fmt.Println("Hello there wonderful people!")
    fmt.Printf("Here is your id: %s\n", uuid.New())
}

module github.com/nathancastelein/go-course-introduction

go 1.20

require github.com/google/uuid v1.5.0

package main

func main() {
....
}

package syntax

import "fmt"

func Boolean() {
	var myFirstBoolean bool
	mySecondBoolean := true
	myThirdBoolean := myFirstBoolean
	myFourstBoolean := new(bool)

	fmt.Println("My variables are: ", myFirstBoolean, mySecondBoolean, myThirdBoolean, myFourstBoolean)
}

func ZeroValue() {
	var myBoolean bool
	var myInt int
	var myString string

	fmt.Println("Zero values are: ", myBoolean, myInt, myString)
	// print "Zero values are:  false 0 "
}

package syntax

import "fmt"

func Boolean() {
	itsTrue, itsFalse := true, false

	fmt.Println("My booleans are: ", itsTrue, itsFalse)
    fmt.Println("Trying some operation: ", itsTrue && itsFalse, itsTrue || itsFalse)
}

package syntax

import "fmt"

func Numeric() {
	var myInt64 int64
	myInt := 10
	myFloat64 := 3.14
	myInt64 = 20

	fmt.Println("Here are numeric types: ", myInt, myInt64, myFloat64)
	fmt.Println("With some operation: ", myInt+int(myInt64), float64(myInt)+myFloat64, myInt-int(myFloat64))
}

package syntax

import "fmt"

func String() {
	var myEmptyString string
	myString := "Hello"
	myStringWithDoubleQuotes := `"Nathan"`
	myMultiLineString := `Line 1
Line 2`

	fmt.Println("Here are some strings: ", myEmptyString, myString, myStringWithDoubleQuotes, myMultiLineString)
	fmt.Println("Size of a string: ", len(myString), len(myEmptyString))
	fmt.Println("Operation on a string: ", myString+" "+myStringWithDoubleQuotes)
}

package syntax

import "fmt"

func Fmt() {
	myAge := 33
	myName := "Nathan"
	mySize := 1.75

	myInformation := fmt.Sprintf("Hello, I'm %s, I have %d years old, and I am %.2fm tall", myName, myAge, mySize)
	fmt.Println(myInformation)
}

func If() {
	if 2 > 1 {
		fmt.Println("Two is superior to one")
	} else if 1+1 == 11 {
		fmt.Println("1 + 1 equals 11")
	} else {
		fmt.Println("We're in the else statement")
	}

	if sum := FuncSumWithVariadicInput(1, 2, 3); sum > 5 {
		fmt.Println("The computed sum was superior to 5: ", sum)
	}
}

func Switch() {
	name := "Nathan"
	switch name {
	case "Nicolas":
		fmt.Println("Hello Nicolas!")
	case "Nathalie":
		fmt.Println("Hello Nathalie!")
	case "Nathan":
		fmt.Println("Hello Nathan!")
	default:
		fmt.Println("Who are you? Who who, who who?")
	}

	myInt := 10
	switch {
	case myInt > 20:
		fmt.Println("What an int!")
	case myInt+5 > 15:
		fmt.Println("Let's add some compute")
	case myInt >= 10:
		fmt.Println("My int is not so big: ", myInt)
	}
}

func For() {
	for myVariable := 0; myVariable < 5; myVariable++ {
		fmt.Println("I'm in a loop: ", myVariable)
	}
    
    for myVariable := range 5 {
		fmt.Println("I'm in a loop: ", myVariable)
    }
    
    for range 5 { // go 1.22+
    	fmt.Println("I'm in a loop")
    }

	myVariable := 0
	for myVariable == 0 {
		myVariable += 5
	}

	for {
		myVariable++
		if myVariable > 10 {
			fmt.Println("Stopping the loop, value: ", myVariable)
			break
		}
	}
}

file/to/open.go

$ go test .

fizzbuzz/step1/fizzbuzz.go

func FizzBuzz(input int) string {
	fizzBuzzValue := ""
	if input%3 == 0 {
		fizzBuzzValue += "Fizz"
	}

	if input%5 == 0 {
		fizzBuzzValue += "Buzz"
	}

	if fizzBuzzValue != "" {
		return fizzBuzzValue
	}

	return fmt.Sprintf("%d", input)
}

package syntax

import "fmt"

func Array() {
	var myIntArray [3]int
	myIntArray[0] = 3
	myIntArray[1] = 2
	myIntArray[2] = 1

	fmt.Println("Here is an int array", myIntArray)
}

func Slice() {
	var mySlice []int // len 0, cap 0
	printSlice(mySlice, "empty slice")

	myOtherSlice := []int{1, 2, 3} // len 3, cap 3
	printSlice(myOtherSlice, "non-empty slice")

	length := 5
	mySliceWithLength := make([]int, length) // len 5, cap 5
	printSlice(mySliceWithLength, "slice with length")

	capacity := 10
	mySliceWithMakeAndCapacity := make([]int, length, capacity) // len 5, cap 10
	printSlice(mySliceWithMakeAndCapacity, "slice with length and capacity")
}

func SliceOperations() {
	mySlice := []int{1, 2, 3}

	myElement := mySlice[0]                         // Accessing an element
	mySlice[2] = myElement * 3                      // Replace an element
	mySlice = append(mySlice, 4)                    // Append a new element at the end
	mySlice[0], mySlice[1] = mySlice[3], mySlice[2] // Swap multiple elements

	printSlice(mySlice, "slice after operations")
}

func SliceIteration() {
	mySlice := []int{1, 2, 3, 4}
    
	sliceSum := 0
	for i := 0; i < len(mySlice); i++ {
		sliceSum += mySlice[i]
	}
	fmt.Println("This is the sum of my slice: ", sliceSum)

	sliceMult := 1
	for i := range mySlice {
		sliceMult *= mySlice[i]
	}
	fmt.Println("This is the multiplication of my slice's elements: ", sliceMult)

	for i, element := range mySlice {
		fmt.Printf("This is the element %d from my slice: %d\n", i, element)
	}

	for _, element := range mySlice {
		fmt.Println("Iterating on my slice: ", element)
	}
}

file/to/open.go

$ go test .

fizzbuzz/step2/multi.go

func multiFizzBuzz(numbers []int) []string {
	results := make([]string, len(numbers))

	for i, number := range numbers {
		results[i] = fizzbuzz(number)
	}
	return results
}

func Map() {
	myMap := map[string]string{
		"France":  "Paris",
		"Belgium": "Brussels",
		"Spain":   "Madrid",
	}
	fmt.Println("Capitals are: ", myMap)

	myMapFromMake := make(map[string]string, 0)
	fmt.Println("An empty map: ", myMapFromMake)
}

func MapOperations() {
	myMap := map[string]string{
		"France": "Paris",
	}

	myMap["Belgium"] = "Brussels" // Assign a new element
	myMap["France"] = "Lille"     // Replace an element's value

	franceCapital := myMap["France"] // Accessing to an element
	fmt.Println("The new capital in France is: ", franceCapital)

	switzerlandCapital, found := myMap["Switzerland"] // Access to an element and check existence
	if found {
		fmt.Println("The capital of Switzerland is: ", switzerlandCapital)
	} else {
		fmt.Println("Looks like we don't know the capital of Switzerland")
	}

	_, found = myMap["Belgium"] // Check existence
	if found {
		fmt.Println("Looks like we know the capital of Belgium!")
	}
}

func MapIteration() {
	myMap := map[string]string{
		"France":  "Paris",
		"Belgium": "Brussels",
	}

	for country := range myMap {
		fmt.Printf("The capital of %s is %s\n", country, myMap[country])
	}

	for country, capital := range myMap {
		fmt.Printf("The capital of %s is %s\n", country, capital)
	}

	for _, capital := range myMap {
		fmt.Println("Oh! I know this capital: ", capital)
	}
}

file/to/open.go

$ go test .

fizzbuzz/step3/multimap.go

func multiFizzBuzzMap(numbers []int) map[int]string {
	result := make(map[int]string, len(numbers))

	for _, number := range numbers {
		result[number] = fizzbuzz(number)
	}
	return result
}

func EmptyFunc() {
	fmt.Println("Hello from empty func")
}

func FuncWithInput(myString string) {
	fmt.Println("Hello from func with input", myString)
}

func FuncWithInputAndOuput(name string) string {
	return fmt.Sprintf("Hello %s", name)
}

func FuncWithMultipleInputsAndOuputs(myString string, myInt1, myInt2 int) (string, int) {
	return fmt.Sprintf("Hello %s", myString), myInt1 + myInt2
}

func FuncWithNamedOutput() (result string) {
	result = "Hello there"
	return
}

func FuncSumWithVariadicInput(numbers ...int) (result int) {
	for _, number := range numbers {
		result += number
	}
	return
}

func CallFuncWithVariadicInput() {
	result := FuncSumWithVariadicInput(1, 2, 3)
	fmt.Println("Result from sum function:", result)

	result = FuncSumWithVariadicInput(1, 2, 3, 4, 5)
	fmt.Println("Result from sum function:", result)

	numbers := []int{10, 20, 30}
	result = FuncSumWithVariadicInput(numbers...)
	fmt.Println("Result from sum function:", result)
}

func Pointers() {
	myInt := 3
	myIntPointer := new(int)
	myIntPointer = &myInt

	fmt.Println("Pointer to int: ", myIntPointer)
    // Print "Pointer to int:  0xc0000ac0b8"
	fmt.Println("Int from pointer: ", *myIntPointer)
    // Print "Pointer to int:  3"
}

type Person struct {
	Name string
	Age  int
}

func InitializeStruct() {
	jessie := Person{
		Name: "Jessie",
		Age:  17,
	}

	james := Person{"James", 17}
    
    fmt.Println("Jessie's age is ", jessie.Age)

	fmt.Println("Famous Team Rocket members: ", jessie, james)
}

func (p *Person) HappyBirthday() {
	p.Age = p.Age + 1
}

func (p Person) YearOfBirth() int {
	return time.Now().Year() - p.Age
}

type UniquePerson struct {
	cardIdNumber string // Is not visible outside the package
	Name         string // Visible and modifiable outside the package
	Age          int    // Visible and modifiable outside the package
}

func NewUniquePerson(cardIdNumber, name string, age int) *UniquePerson {
	return &UniquePerson{
		cardIdNumber: cardIdNumber,
		Name:         name,
		Age:          age,
	}
}

file/to/open.go

$ go test

fizzbuzz/step4/fizzstruct.go

func (f *FizzBuzz) Compute() {
	f.result = fizzbuzz(f.number)
}

file/to/open.go

$ go test .

# or

$ go run cmd/api/main.go
$ curl 'localhost:8080/?number=15'

fizzbuzz/step4/server.go

func FizzBuzzHandler(w http.ResponseWriter, r *http.Request) {
	// Get query parameter "number" from URL
	numberString := r.URL.Query().Get("number")	

	// Transform number from string to int
	number, err := strconv.Atoi(numberString)
	// If invalid input, write response header HTTP 400 then return
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	// Compute FizzBuzz on number
	result := fizzbuzz(number)

	// Write response header HTTP 200
	w.WriteHeader(http.StatusOK)
	// Write result on response
	fmt.Fprint(w, result)
}