Go Basics

// var — explicit type, usable at package scope
var name string = "gopher"
var count int           // zero value: 0
var active bool         // zero value: false

// var block — cleaner for multiple declarations
var (
    host string = "localhost"
    port int    = 5432
    tls  bool
)

// := short declaration — type inferred, function scope only
name := "gopher"
count := 42
ratio := 3.14     // inferred as float64

// multiple assignment in one line
x, y := 10, 20
a, b, c := "hello", true, 3.14

// swap without a temp variable
x, y = y, x

// Every type has a zero value — Go never leaves memory uninitialised
var i int        // 0
var f float64    // 0.0
var b bool       // false
var s string     // "" (empty string)
var p *int       // nil
var sl []int     // nil (a nil slice is valid and has length 0)
var m map[string]int // nil (reading is ok, writing panics)

// _ discards a value — suppresses "declared and not used" error
_, err := fmt.Println("hi")
_ = err

// useful when you only want one value from a multi-return
val, _ := strconv.Atoi("42")   // ignore error

// Bitmask flags — each const is a distinct bit
type Permission uint
const (
    Read    Permission = 1 << iota // 1
    Write                           // 2
    Execute                         // 4
)

p := Read | Write            // combine flags
p&Read != 0                  // check if flag is set: true

// iota with a formula
type Weekday int
const (
    Sunday Weekday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)
fmt.Println(Wednesday) // 3

x := 42
p := &x          // p is *int — holds address of x
*p = 100        // dereference: sets x to 100
fmt.Println(x)  // 100

// new() allocates and returns a pointer to a zero value
n := new(int)   // *int pointing to 0
*n = 7

// Struct fields through a pointer — no need to write (*s).Field
type Point struct{ X, Y int }
pt := &Point{1, 2}
pt.X = 10        // auto-dereferenced

// Go passes everything by value — pointer lets the callee mutate
func increment(n *int) {
    *n++
}

count := 5
increment(&count)
fmt.Println(count) // 6

// Without the pointer, the original is unchanged
func noEffect(n int) { n++ }
noEffect(count)
fmt.Println(count) // still 6

// Always nil-check before dereferencing
var p *int
if p != nil {
    fmt.Println(*p)
}

s := "Hello, 世界"

fmt.Println(len(s))                    // 13 — bytes, not characters
fmt.Println(utf8.RuneCountInString(s))  // 9 — Unicode code points

// Indexing gives a byte (uint8)
fmt.Printf("%T %v\n", s[0], s[0])     // uint8 72

// range over string decodes UTF-8 and yields runes
for i, r := range s {
    fmt.Printf("%d: %c (%d)\n", i, r, r)
}
// 0: H (72)
// 1: e (101)
// ...  7: 世 (19990)   ← byte index 7, not character index 7
// 10: 界 (30028)

s := "Hello, 世界"

// Convert to []rune for character-index access
runes := []rune(s)
fmt.Println(len(runes))   // 9
fmt.Println(runes[7])     // 19990 — '世'
fmt.Println(string(runes[7])) // "世"

// Rune literals use single quotes
var r rune = 'A'           // 65
var cjk rune = '世'        // 19990

// string() converts a rune (code point) back to its UTF-8 bytes
fmt.Println(string(65))    // "A"
fmt.Println(string([]rune{'H', 'i'})) // "Hi"

// C-style
for i := 0; i < 5; i++ {
    fmt.Print(i, " ") // 0 1 2 3 4
}

// While-style — condition only
n := 1
for n < 100 {
    n *= 2
}
fmt.Println(n) // 128

// Infinite loop — exit with break or return
for {
    if done { break }
}

// break/continue work as expected
for i := 0; i < 10; i++ {
    if i%2 == 0 { continue } // skip evens
    if i > 7    { break }    // stop at 8
    fmt.Print(i, " ")          // 1 3 5 7
}

nums := []int{10, 20, 30}

// range slice → index, value
for i, v := range nums {
    fmt.Println(i, v) // 0 10, 1 20, 2 30
}

// discard index
for _, v := range nums { fmt.Println(v) }

// range map → key, value (iteration order is random)
ages := map[string]int{"alice": 30, "bob": 25}
for k, v := range ages {
    fmt.Printf("%s is %d\n", k, v)
}

// range string → byte index, rune (UTF-8 decoded)
for i, r := range "Go" {
    fmt.Printf("%d: %c\n", i, r) // 0: G, 1: o
}

// range channel — reads until channel is closed
ch := make(chan int, 3)
ch <- 1; ch <- 2; ch <- 3; close(ch)
for v := range ch { fmt.Print(v, " ") } // 1 2 3

// Variadic — ...T collects extra args into a slice
func sum(nums ...int) int {
    total := 0
    for _, n := range nums { total += n }
    return total
}
sum(1, 2, 3)        // 6
sum(1, 2, 3, 4, 5) // 15
s := []int{1, 2, 3}
sum(s...)           // spread a slice with ...

// Functions are first-class — assignable, passable, returnable
add := func(a, b int) int { return a + b }
apply := func(f func(int, int) int, x, y int) int {
    return f(x, y)
}
apply(add, 3, 4)  // 7

// Multiple returns — idiomatic (value, error) pattern
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)
}

// Named returns — named in signature, bare return fills them
// Good for short functions; avoid in longer ones (hurts readability)
func minMax(a []int) (min, max int) {
    min, max = a[0], a[0]
    for _, v := range a[1:] {
        if v < min { min = v }
        if v > max { max = v }
    }
    return  // bare return
}

// The inner function closes over `count` in the outer scope
func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

counter := makeCounter()
fmt.Println(counter()) // 1
fmt.Println(counter()) // 2
fmt.Println(counter()) // 3

other := makeCounter()  // independent counter, own `count`
fmt.Println(other())   // 1

// Pre-Go 1.22: all closures capture the SAME loop variable
funcs := make([]func(), 3)
for i := 0; i < 3; i++ {
    funcs[i] = func() { fmt.Println(i) }
}
funcs[0]() // 3 — surprise! i is 3 by the time this runs
funcs[1]() // 3
funcs[2]() // 3

// Fix: shadow the variable inside the loop body
for i := 0; i < 3; i++ {
    i := i  // new variable per iteration
    funcs[i] = func() { fmt.Println(i) }
}
funcs[0]() // 0
funcs[1]() // 1
funcs[2]() // 2

// Go 1.22+ fixes this automatically — each iteration gets its own i

func describe(i interface{}) string {
    switch v := i.(type) {
    case int:
        return fmt.Sprintf("int: %d", v)
    case string:
        return fmt.Sprintf("string: %q", v)
    case bool:
        return fmt.Sprintf("bool: %v", v)
    case []int:
        return fmt.Sprintf("[]int of len %d", len(v))
    default:
        return fmt.Sprintf("unknown: %T", v)
    }
}

describe(42)          // "int: 42"
describe("hello")    // "string: \"hello\""
describe([]int{1,2}) // "[]int of len 2"

// fallthrough — rare; forces next case to execute unconditionally
switch n {
case 1:
    fmt.Println("one")
    fallthrough
case 2:
    fmt.Println("one or two")
}

// Classic use: guarantee resource cleanup regardless of return path
func readFile(path string) (string, error) {
    f, err := os.Open(path)
    if err != nil { return "", err }
    defer f.Close()  // runs when readFile returns

    // ... read file ...
    return content, nil
}

// Multiple defers — LIFO (last-in, first-out)
defer fmt.Println("first")
defer fmt.Println("second")
defer fmt.Println("third")
// Output: third, second, first

// The argument i is evaluated NOW (when defer is called)
for i := 0; i < 3; i++ {
    defer fmt.Println(i)
}
// Prints: 2, 1, 0  — values captured at each defer call

// Deferred func can read named return values (and modify them)
func double(n int) (result int) {
    defer func() { result *= 2 }()
    result = n
    return   // returns n*2
}
double(5) // 10

import (
    "errors"
    "fmt"
)

// errors.New — simple, no formatting
var ErrNotFound = errors.New("not found")

// fmt.Errorf — with context; %w wraps for unwrapping later
func getUser(id int) (*User, error) {
    u, ok := db[id]
    if !ok {
        return nil, fmt.Errorf("getUser %d: %w", id, ErrNotFound)
    }
    return u, nil
}

// errors.Is — checks the chain for a target error
_, err := getUser(99)
errors.Is(err, ErrNotFound) // true — works even when wrapped

// errors.As — extracts a specific error type from the chain
var ne *NetworkError
if errors.As(err, &ne) {
    fmt.Println("network error:", ne.Code())
}

// Implement the error interface: Error() string
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation: %s — %s", e.Field, e.Message)
}

func validate(age int) error {
    if age < 0 {
        return &ValidationError{Field: "age", Message: "must be non-negative"}
    }
    return nil
}

err := validate(-1)
fmt.Println(err) // "validation: age — must be non-negative"

var ve *ValidationError
if errors.As(err, &ve) {
    fmt.Println(ve.Field) // "age"
}