Go — The Cheat Sheet

cheat sheet · golang

The Go
Cheat Sheet

A compiled, statically typed, garbage-collected language built for simplicity and concurrency. Less is exponentially more.

Hello, World

package main

import "fmt"

func main() {
    fmt.Println("Hello, Gopher!")
}

Run with go run main.go. Every executable lives in package main with a main() entry point.

Variables & Constants

var a int = 10
var b = 3.14        // inferred
c := "short form"     // fn scope only

var (
    x, y int   = 1, 2
    name string = "Go"
)

const Pi = 3.14159
const (
    A = iota   // 0
    B          // 1
    C          // 2
)

Unused variables are a compile error. := declares and assigns in one step.

Basic Types

// numeric
int  int8 int16 int32 int64
uint uint8(byte) uint64 uintptr
float32 float64
complex64 complex128
rune   // alias for int32, a code point

// other
bool      // true / false
string    // immutable bytes

// zero values
0  0.0  ""  false  nil

Every type has a zero value — no uninitialized memory.

Functions

func add(a, b int) int {
    return a + b
}

// multiple returns
func divmod(a, b int) (int, int) {
    return a / b, a % b
}

// named returns
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return          // "naked" return
}

// variadic + closure
func sum(nums ...int) int { ... }
inc := func(n int) int { return n+1 }

Functions are first-class values. They can be passed, returned, and closed over.

⎇

Control Flow

if x := f(); x < 0 {
    ...
} else if x == 0 {
    ...
} else {
    ...
}

switch day {
case "Sat", "Sun":
    fmt.Println("weekend")
default:
    fmt.Println("weekday")
}

switch {              // tagless
case x > 10: ...
}

No parentheses around conditions. switch cases don't fall through (use fallthrough if needed).

↻

Loops

// the only loop keyword: for
for i := 0; i < 10; i++ { ... }

// while-style
for n < 100 { n *= 2 }

// infinite
for { ... break }

// range over slice / map / string
for i, v := range slice { ... }
for key, val := range myMap { ... }
for _, r := range "héllo" { ... } // runes

for is Go's only loop. Use _ to discard the index or value.

[ ]

Arrays & Slices

// array: fixed size, part of type
var arr [3]int = [3]int{1, 2, 3}

// slice: dynamic, the workhorse
s := []int{1, 2, 3}
s = append(s, 4, 5)
s = make([]int, 0, 10)  // len 0, cap 10

sub := s[1:3]   // elems 1,2 (shares backing)
len(s)  cap(s)
copy(dst, src)

Slices are views over an array. append may reallocate — always reassign the result.

{ }

Maps

m := make(map[string]int)
m["a"] = 1

m := map[string]int{"x": 1, "y": 2}

// comma-ok: does the key exist?
v, ok := m["a"]
if ok { ... }

delete(m, "a")
len(m)

Reading a missing key returns the zero value, not an error. Map iteration order is random.

▦

Structs

type Point struct {
    X, Y int
    Tag  string `json:"tag"`
}

p := Point{X: 1, Y: 2}
p := Point{1, 2, "o"}   // positional
p.X = 5

// embedding (composition)
type Circle struct {
    Point          // embedded
    Radius float64
}
c.X  // promoted from Point

Go favors composition over inheritance via embedding. Struct tags drive encoding (e.g. JSON).

Pointers

x := 10
p := &x        // p points to x
*p = 20        // x is now 20

func grow(n *int) { *n++ }
grow(&x)

// new returns a pointer
q := new(int)   // *int -> 0

No pointer arithmetic. The GC handles freeing. Pass *T to mutate a caller's value.

·m

Methods

type Rect struct { W, H float64 }

// value receiver (read-only copy)
func (r Rect) Area() float64 {
    return r.W * r.H
}

// pointer receiver (can mutate)
func (r *Rect) Scale(f float64) {
    r.W *= f
    r.H *= f
}

r := Rect{3, 4}
r.Area()       // 12

Methods can attach to any named type, not just structs. Be consistent with receiver types.

⌘

Interfaces

type Shape interface {
    Area() float64
}

// satisfied implicitly — no "implements"
func describe(s Shape) {
    fmt.Println(s.Area())
}

// type assertion / switch
v, ok := s.(Rect)
switch t := s.(type) {
case Rect:   ...
case Circle: ...
}

interface{}  // or `any` — holds anything

Interfaces are satisfied structurally — if it has the methods, it qualifies. Keep them small.

Error Handling

// errors are values, returned explicitly
f, err := os.Open("file.txt")
if err != nil {
    return fmt.Errorf("open: %w", err)
}
defer f.Close()

// custom error
type MyErr struct{ Code int }
func (e *MyErr) Error() string {
    return fmt.Sprintf("err %d", e.Code)
}

errors.Is(err, target)
errors.As(err, &myErr)

No exceptions for ordinary errors. Wrap with %w, inspect with errors.Is/As.

⤺

defer · panic · recover

// defer runs at function return (LIFO)
defer fmt.Println("last")
defer fmt.Println("first")

// recover from a panic
func safe() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recovered:", r)
        }
    }()
    panic("boom")
}

defer is ideal for cleanup. Reserve panic for truly unrecoverable states.

⫶

Goroutines

// launch concurrently — cheap (KBs)
go doWork()
go func() { ... }()

// WaitGroup: wait for many
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(i int) {
        defer wg.Done()
        work(i)
    }(i)
}
wg.Wait()

Goroutines are scheduled onto OS threads by the runtime. Don't leak them — give each a way to stop.

⇄

Channels

ch := make(chan int)       // unbuffered
ch := make(chan int, 10)   // buffered

ch <- 42       // send
v := <-ch      // receive
close(ch)

for v := range ch { ... }  // until closed

// select: wait on multiple ops
select {
case v := <-ch1: ...
case ch2 <- x:  ...
default:       // non-blocking
}

Don't communicate by sharing memory; share memory by communicating. Only the sender should close.

<T>

Generics (1.18+)

func Map[T, U any](s []T, f func(T) U) []U {
    r := make([]U, len(s))
    for i, v := range s {
        r[i] = f(v)
    }
    return r
}

// type constraint
type Number interface {
    ~int | ~float64
}
func Sum[T Number](xs []T) T { ... }

Type parameters in [ ]. Constraints are interfaces listing allowed types or methods.

Strings & Formatting

strings.Split(s, ",")
strings.Join(parts, "-")
strings.Contains(s, "go")
strings.ToUpper(s)  strings.TrimSpace(s)
strings.ReplaceAll(s, "a", "b")

strconv.Atoi("42")        // str -> int
strconv.Itoa(42)          // int -> str

fmt.Sprintf("%d %s %.2f %v %+v", ...)
// %d int  %s str  %v any  %T type  %q quoted

Use a strings.Builder for efficient concatenation in loops.

⊞

Packages & Modules

package mypkg          // top of every file

import (
    "fmt"
    "strings"
    m "math/rand"     // alias
    _ "image/png"     // side-effect only
)

// Exported = Capitalized (public)
// unexported = lowercase (package-private)
func Public()  {}
func private() {}

Capitalization controls visibility. Init a module with go mod init example.com/m.

⌗

Go Toolchain (CLI)

go run .            # compile + run
go build            # produce a binary
go test ./...       # run all tests
go test -race       # race detector
go fmt ./...        # format code
go vet ./...        # static checks
go mod tidy         # clean up deps
go get pkg@latest    # add a dependency
go doc fmt.Println   # read docs

A test file ends in _test.go; test funcs are func TestX(t *testing.T).

Satyam Kumar Das Founder & Solutions Architect · AppScale LLP

satyam@appscale.in
linkedin.com/in/satyamkumar