Go Basics

// Every Go file starts with package
package main

import "fmt"

// Entry point
func main() {
    fmt.Println("Hello, Go!")
}

// Single import
import "fmt"

// Grouped import (preferred)
import (
    "fmt"
    "math"
    "strings"
)

// Alias an import
import f "fmt"
f.Println("aliased")

// No semicolons needed (auto-inserted)
// Opening { MUST be on same line

// Unused imports → compile error!
// Unused variables → compile error!

// := infers type and declares
x := 42       // short declaration
var y = 42    // explicit var
var z int     // zero value = 0

// func name(params) returnType
func add(a int, b int) int {
    return a + b
}

// Shared param type shorthand
func add(a, b int) int {
    return a + b
}

// Call it
result := add(3, 4)  // 7

// Go functions can return multiple values
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("div by zero")
    }
    return a / b, nil
}

// Unpack both values
val, err := divide(10, 3)
// Discard with blank identifier _
val, _   := divide(10, 3)

// Variadic — any number of args
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

// Anonymous function (closure)
double := func(x int) int {
    return x * 2
}
fmt.Println(double(5))  // 10

import (
    "fmt"
    "time"
)

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

func main() {
    // go = launch concurrently
    go sayHello("Alice")
    go sayHello("Bob")

    // Wait (crude — use WaitGroup in prod)
    time.Sleep(100 * time.Millisecond)
}

// Create a channel
ch := make(chan int)

// Send in goroutine
go func() {
    ch <- 42   // send value
}()

// Receive in main
val := <-ch  // receive value
fmt.Println(val)  // 42

// Buffered channel
bch := make(chan int, 5)
defer close(bch)

func readFile() {
    f, _ := os.Open("data.txt")
    defer f.Close()  // runs when func exits

    // Multiple defers — LIFO (stack)
    defer fmt.Println("third")
    defer fmt.Println("second")
    defer fmt.Println("first")
    // prints: first, second, third
}

// Compile error — unused import
import "fmt"  // Error if never used!
// Fix: remove unused imports
// Use goimports to auto-manage

// Compile error — unused variable
x := 42           // Error if x never read!
// Fix: use _ to explicitly discard
_ = x

// Nil pointer dereference
var p *Person
p.Name  // PANIC! p is nil
// Fix: p = &Person{}

// Assignment to nil map
var m map[string]int
m["key"] = 1  // PANIC!
// Fix: m = make(map[string]int)

// Deadlock — nothing reads from ch
ch := make(chan int)
ch <- 42    // blocks forever!
// Fix: read in a goroutine
go func() { ch <- 42 }()
val := <-ch

// Forgot to close channel
defer close(ch)  // always close!