Go Cheatsheet: Goroutines, Channels and Interfaces Reference

# Install (macOS / Linux). Prefer the official tarball; package managers lag.
brew install go                     # macOS
sudo apt install golang-go          # Debian/Ubuntu

# Or pin a version with the go command itself
go install golang.org/dl/go1.22@latest
go1.22 download

# Project setup — modules, no GOPATH needed
mkdir myapp && cd myapp
go mod init github.com/me/myapp
go get github.com/spf13/cobra@latest
go mod tidy                         # prune unused, add missing

# Daily commands
go run ./...                        # run all packages
go build -o bin/app ./cmd/app       # build a binary
go test ./...                       # run all tests
go vet ./... && gofmt -w .          # static checks + format

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {            // ranges until jobs is closed
        time.Sleep(50 * time.Millisecond)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 5)        // buffered → non-blocking up to 5
    results := make(chan int, 5)
    var wg sync.WaitGroup

    for w := 1; w <= 3; w++ {        // fan out 3 workers
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)                       // signal "no more work"

    go func() { wg.Wait(); close(results) }()

    for r := range results {
        fmt.Println(r)
    }
}

package main

import (
    "errors"
    "fmt"
    "os"
)

// Custom error with structured context
type NotFoundError struct {
    Resource string
    ID       string
}

func (e *NotFoundError) Error() string {
    return fmt.Sprintf("%s %q not found", e.Resource, e.ID)
}

// Wrapping: %w preserves the chain so errors.Is / errors.As can unwrap
func loadUser(id string) error {
    _, err := os.ReadFile("users/" + id + ".json")
    if err != nil {
        return fmt.Errorf("loadUser(%s): %w", id, err)
    }
    return nil
}

func main() {
    err := loadUser("u_42")

    if errors.Is(err, os.ErrNotExist) {
        fmt.Println("file missing — fall back to cache")
    }

    var nfe *NotFoundError
    if errors.As(err, &nfe) {
        fmt.Printf("typed error: %+v\n", nfe)
    }
}

package main

import (
    "cmp"
    "fmt"
    "slices"
)

// Generic function — works for any ordered type
func Max[T cmp.Ordered](xs []T) T {
    m := xs[0]
    for _, x := range xs[1:] {
        if x > m { m = x }
        }
    return m
}

// Generic constraint with a method set
type Stringer interface { String() string }

func Join[T Stringer](xs []T, sep string) string {
    out := ""
    for i, x := range xs {
        if i > 0 { out += sep }
        out += x.String()
    }
    return out
}

func main() {
    fmt.Println(Max([]int{3, 7, 2}))            // 7
    fmt.Println(Max([]string{"go", "is", "fun"})) // "is"

    nums := []int{5, 1, 4, 2, 3}
    slices.Sort(nums)                            // generic stdlib
    fmt.Println(slices.Contains(nums, 4))         // true
}

package main

import (
    "context"
    "encoding/json"
    "errors"
    "fmt"
    "log/slog"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

type Greeting struct {
    Name    string `json:"name"`
    Message string `json:"message"`
}

func handleHello(w http.ResponseWriter, r *http.Request) {
    name := r.PathValue("name")                  // Go 1.22 path params
    g := Greeting{Name: name, Message: "hi " + name}
    w.Header().Set("Content-Type", "application/json")
    _ = json.NewEncoder(w).Encode(g)
}

func main() {
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    slog.SetDefault(logger)

    mux := http.NewServeMux()
    mux.HandleFunc("GET /hello/{name}", handleHello)

    srv := &http.Server{Addr: ":8080", Handler: mux}

    go func() {
        slog.Info("listening", "addr", srv.Addr)
        if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
            slog.Error("listen", "err", err); os.Exit(1)
        }
    }()

    // Graceful shutdown on SIGINT / SIGTERM
    stop := make(chan os.Signal, 1)
    signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
    <-stop

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        fmt.Println(err)
    }
}