Go (Golang) Cheat Sheet

Go (Golang) is a statically typed, compiled programming language designed for simplicity, performance, and built-in concurrency. This Go cheatsheet is an example-driven reference covering core syntax, data structures, interfaces, error handling, and concurrency primitives.

Basic Program Structure

package main

import "fmt"

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

Running & Building

go run main.go
go build
go build -o app

Variables

var a int = 10
var b = 20
c := 30

var (
    x int = 1
    y int = 2
)

Constants

const Pi = 3.14

const (
    A = iota
    B
    C
)

Basic Types

int
int64
float64
bool
string

var s string = "text"

Control Flow

if

if x > 10 {
    fmt.Println("large")
}

if v := x * 2; v > 10 {
    fmt.Println(v)
}

switch

switch x {
case 1:
    fmt.Println("one")
case 2:
    fmt.Println("two")
default:
    fmt.Println("other")
}

Loops

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

for x > 0 {
    x--
}

for {
    break
}

Functions

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

result := add(2, 3)

Multiple Return Values

func divide(a, b int) (int, int) {
    return a / b, a % b
}

q, r := divide(10, 3)

Named Return Values

func sum(a, b int) (result int) {
    result = a + b
    return
}

Variadic Functions

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

Arrays

var arr [3]int = [3]int{1, 2, 3}

Slices

numbers := []int{1, 2, 3}
numbers = append(numbers, 4)

sub := numbers[1:3]

Maps

m := map[string]int{
    "a": 1,
    "b": 2,
}

value, ok := m["a"]

Iteration

for i, v := range numbers {
    fmt.Println(i, v)
}

for key, value := range m {
    fmt.Println(key, value)
}

Structs

type Point struct {
    X int
    Y int
}

p := Point{X: 10, Y: 20}

Struct Methods

func (p Point) Sum() int {
    return p.X + p.Y
}

func (p *Point) Move(dx, dy int) {
    p.X += dx
    p.Y += dy
}

Interfaces

type Speaker interface {
    Speak() string
}

type Person struct {
    Name string
}

func (p Person) Speak() string {
    return p.Name
}

Empty Interface

var v interface{} = 10

switch t := v.(type) {
case int:
    fmt.Println("int")
case string:
    fmt.Println("string")
}

Type Assertions

value := v.(int)

value, ok := v.(string)

Error Handling

func read() error {
    return errors.New("failed")
}

if err := read(); err != nil {
    fmt.Println(err)
}

Defer

func example() {
    defer fmt.Println("done")
    fmt.Println("working")
}

Panic & Recover

func mayFail() {
    panic("error")
}

func safe() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recovered")
        }
    }()
    mayFail()
}

Goroutines

go fmt.Println("running concurrently")

go func() {
    fmt.Println("anonymous goroutine")
}()

Channels

ch := make(chan int)

go func() {
    ch <- 42
}()

value := <-ch

Buffered Channels

ch := make(chan int, 2)
ch <- 1
ch <- 2

Range Over Channels

for v := range ch {
    fmt.Println(v)
}

Select

select {
case v := <-ch:
    fmt.Println(v)
default:
    fmt.Println("no value")
}

Mutex

import "sync"

var mu sync.Mutex

mu.Lock()
mu.Unlock()

WaitGroup

var wg sync.WaitGroup

wg.Add(1)
go func() {
    defer wg.Done()
    fmt.Println("done")
}()

wg.Wait()

File I/O

import "os"

data, _ := os.ReadFile("file.txt")

os.WriteFile("file.txt", []byte("text"), 0644)

JSON

import "encoding/json"

type User struct {
    Name string
    Age  int
}

b, _ := json.Marshal(User{Name: "A", Age: 20})

var u User
json.Unmarshal(b, &u)