Go Cheat Sheet

$ go version

package main

import "fmt"
import r "math/rand"

func main() {
    fmt.Println("Hello", r.Int())
}

$ ### RUN ###
$ go run .
$ ### VET & BUILD & RUN ###
$ go vet hello.go
$ go build hello.go
$ ./hello
$ ### INSTALL & RUN ###
$ go install hello.go
$ $GOBIN/hello

// declaration
var msg string
msg = "Hello"
// short with type inference
msg := "Hello"
// constants
const Pi = 3.14159265358979323846264338327950288419716939937510582097494459
ip, port := "127.0.0.1", "8080"
fmt.Println(ip + ":" + port)
a, b := 1, 2
a, b = b, a // swap, 2 1

str := "Hello" // string
str := `Multiline
 string`
num := 3 // int
num := 3. // float64
num := 3 + 4i // complex128
var c rune = '♬' // UTF-8
num := byte('A') // byte/uint8
fmt.Printf("%T\n", i) // print
s := reflect.TypeOf(i).String()
type Weight float64 // custom
w := Weight(70) // conversion

i := 42
var pi *int = &i // point to i
p := &i // point to i
*p = *p * 2 // dereferencing
s := struct{ x int }{42}
ps := &s
ps.x == (*ps).x // equivalent

var a [5]int // fixed size
a[0] = 3 // assignment
a := [3]int {1,2,3}
a := [...]int {1,2,3,4,5}
a := [...]int{1, 3: 2, 3, 6: -1} // [1 0 0 2 3 0 -1]
var a [2][3]int
pa := *[32]byte{}

var si []int // dynamic size
si := []int {1,2,3}
sb := []byte("Hello")
ss := make([]string, 3)
ss = append(ss, "d", "e")
dst := make([]string, len(ss))
copy(dst, ss)
x := ss[2:5] // elements 2,3,4
y := ss[:5] // elements < 5

m := make(map[string]int)
m["key1"] = 42
fmt.Println("map: ", m)
m := map[string]int{"foo": 1,
     "bar": 2} // initialize
v := m["key1"]
_, contains := m["key2"]
length := len(m)
delete(m, "key1")

i := 0
for i := 0; i < 3; i++ {
    fmt.Println(i) // 0, 1, 2
}
for i <= 3 {
    i = i + 1
    fmt.Println(i) // 1, 2, 3, 4
}
for {
    fmt.Println(i) // 4, 8, 16, 17, 18
    if i < 10 {
        i *= 2
        continue
    } else if i > 17 {
        break
    }
    i++
}
fmt.Println(i) // 18

s := []string{"a", "b", "c"}
for idx, val := range s {
    fmt.Println(idx, val) // 0 a, 1 b, 2 c
}
m := map[string]int{"a": 1, "b": 5}
for k, v := range m {
    fmt.Println(k, v) // EITHER: b 5, a 1 OR: a 1, b 5
}

if d == "Sun" || d == "Sat" {
    /**/
} else if d == "Mon" && foo() {
    /**/
} else if _, err := f();
err != nil {
    /**/
} else {
    /**/
}

switch day := time.Now().Weekday(); day {
case 0:
    fallthrough
case 6:
    fmt.Println("Weekend")
default:
    fmt.Println("Workday")
}

func add(a int, b int) float64 {
	return float64(a + b)
}
func add(a int, b int) (c int) {
	c = a + b
	return
}
func tuple() (int, int) {
    return 4, 2
}
x, y := tuple()
func variadic(nums ...int) int {
    return len(nums)
}
n := variadic(1, 2, 3, 5) // 4

func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}
myLambda := func() bool {
    return true
}

file, err := os.Create("foo")
if err != nil {
    return err
}
defer func() {
    file.Close()
}()

type Person struct {
    name string
    age int
}
p := Person{ "Bob", 4}
p := Person{name: "Bob", age: 4}
p.age = 30

func (p Person) IsTeen() bool {
    return p.age > 12 && p.age < 20
}
func (p *Person) Aging(y int) {
    p.age = p.age + y
}
p.IsTeen()
p.Aging(1)

type geometry interface {
	area() float64
	perim() float64
}
func measure(g geometry) { fmt.Println(g.area(), g.perim()) }
type rect struct{ width, height float64 }
func (r rect) area() float64  { return r.width * r.height }
func (r rect) perim() float64 { return 2. * (r.width + r.height) }
r := rect{width: 2, height: 4}
measure(r)

func f(c chan int) {}
c := make(chan int)
cb := make(chan int, bufferLen)
go func() {
    fmt.Println(<-c)
}()
c <- 2 // send 2 to c
x, y := <-c, <-c // recv from c
close(c) // close chan
select {
case c <- x:
    /**/
case <-quit:
    return
}

var mu sync.Mutex
mu.Lock()
mu.Unlock()
var once sync.Once
once.Do(func() { })
var wg sync.WaitGroup
wg.Add(1)
wg.Done()
wg.Wait()