Go Cheat Sheet

var name string = "Alice"
age := 30           // short declaration
const pi = 3.14
var (
    x int
    y float64
    z bool
)

string  bool
int  int8  int16  int32  int64
uint  uint8  uint16  uint32  uint64
float32  float64
byte (alias for uint8)
rune (alias for int32)

i := 42
f := float64(i)
s := strconv.Itoa(i)
n, _ := strconv.Atoi("42")

// int: 0,  float: 0.0,  bool: false
// string: "",  pointer: nil
// slice/map/chan/func/interface: nil

nums := []int{1, 2, 3}
nums = append(nums, 4, 5)
len(nums)  // 5
cap(nums)  // varies
sub := nums[1:3]  // [2, 3]

s := make([]int, 5)     // len=5, cap=5
s := make([]int, 0, 10) // len=0, cap=10

m := map[string]int{"a": 1, "b": 2}
m["c"] = 3
val, ok := m["a"]  // val=1, ok=true
delete(m, "b")
len(m)

for i, v := range nums { ... }
for k, v := range m { ... }
for i := range nums { ... }  // index only

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

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3)

func counter() func() int {
    n := 0
    return func() int {
        n++
        return n
    }
}

func readFile(path string) {
    f, err := os.Open(path)
    if err != nil { return }
    defer f.Close()
    // use f...
}

type User struct {
    Name  string
    Email string
    Age   int
}

u := User{Name: "Alice", Age: 30}
p := &User{Name: "Bob"}
u.Name  // "Alice"

func (u User) String() string {
    return fmt.Sprintf("%s (%d)", u.Name, u.Age)
}

func (u *User) SetAge(age int) {
    u.Age = age  // pointer receiver mutates
}

type Admin struct {
    User          // embedded struct
    Permissions []string
}
a := Admin{User: User{Name: "Alice"}, Permissions: []string{"all"}}
a.Name  // promoted from User

type Reader interface {
    Read(p []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

var i interface{} = "hello"
s := i.(string)        // panics if wrong
s, ok := i.(string)    // safe

switch v := i.(type) {
case string:
    fmt.Println("string:", v)
case int:
    fmt.Println("int:", v)
default:
    fmt.Println("unknown")
}

val, err := doSomething()
if err != nil {
    return fmt.Errorf("doSomething: %w", err)
}

type NotFoundError struct {
    ID string
}

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

if errors.Is(err, os.ErrNotExist) { ... }

var nfe *NotFoundError
if errors.As(err, &nfe) {
    fmt.Println(nfe.ID)
}

go func() {
    fmt.Println("running concurrently")
}()

ch := make(chan int)     // unbuffered
ch := make(chan int, 10) // buffered
ch <- 42                // send
val := <-ch             // receive
close(ch)

select {
case msg := <-ch1:
    fmt.Println(msg)
case ch2 <- val:
    fmt.Println("sent")
case <-time.After(5 * time.Second):
    fmt.Println("timeout")
}

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