Go Cheat Sheet

By Syncfusion®, Inc. · Last updated November 11, 2026

A lookup page for the whole course: one table per topic, from data types and keywords to files, JSON, goroutines and context.

What Is This Page?

Reference page = a page you look things up in, not one you read from top to bottom.

Nobody remembers every function name. Programmers remember that a tool exists, then look up how to spell it.

This page gives you:

• one table per topic, in course order
• a Run box wherever seeing beats reading
• the traps worth keeping in your head

Simple lesson: remember that a tool exists, and look up the details here.

A Real-World Example

A developer writing a marks server forgets whether it is strings.Trim or strings.TrimSpace. They do not reread a whole tutorial. They open a reference, find the strings table, and get the answer in seconds. This page is that reference for everything in the course.

types and operators

if, switch, for

functions, packages

slices, maps, structs

interfaces, errors

files, goroutines

Go

Every topic of the course, on one page.

Here is most of the course working together in one program:

The whole course in one program

package main

import (
	"errors"
	"fmt"
	"sort"
)

type Result struct {
	Name    string
	Subject string
	Mark    int
}

func (r Result) Grade() string {
	if r.Mark >= 35 {
		return "pass"
	}
	return "fail"
}

var ErrEmpty = errors.New("no results")

func average(rs []Result) (float64, error) {
	if len(rs) == 0 {
		return 0, ErrEmpty
	}
	total := 0
	for _, r := range rs {
		total += r.Mark
	}
	return float64(total) / float64(len(rs)), nil
}

func main() {
	results := []Result{
		{"Asha", "Maths", 78},
		{"Ravi", "Science", 85},
		{"Meera", "English", 30},
	}
	sort.Slice(results, func(i, j int) bool { return results[i].Mark > results[j].Mark })

	count := map[string]int{}
	for _, r := range results {
		fmt.Printf("%-8s%-10s%4d  %s\n", r.Name, r.Subject, r.Mark, r.Grade())
		count[r.Grade()]++
	}

	avg, err := average(results)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("%d of %d passed, average %.1f\n", count["pass"], len(results), avg)
}

Ravi    Science     85  pass
Asha    Maths       78  pass
Meera   English     30  fail
2 of 3 passed, average 64.3

What You Will Learn

On this page, you will find:

1. The syntax for every topic in the course.
2. Run boxes for the trickiest parts.
3. The traps worth remembering, in one table.

Data Types

Every basic type from the course, side by side:

The ways to make a variable:

Keywords

Keyword = a word Go keeps for itself. You cannot use it as a name.

Go has only 25 keywords:

int, string, true, nil, len and append are not keywords. They are built-in names.

Operators

The operator groups:

Variables, types and operators

package main

import (
	"fmt"
	"strconv"
)

const passMark = 35

func main() {
	name := "Asha"
	marks, _ := strconv.Atoi("82")
	avg := float64(marks+90) / 2
	fmt.Println(name, marks >= passMark, avg, 17%5, 1<<3)
}

Asha true 86 2 8

Integer division drops the part after the point: 7 / 2 is 3. Convert first for 3.5: float64(7) / 2.

Conditional Statements

Loops

Go has one loop keyword, for, in four shapes:

What range gives you:

Functions

Conditions, loops and functions

package main

import "fmt"

func grade(m int) string {
	switch {
	case m >= 90:
		return "A"
	case m >= 75:
		return "B"
	default:
		return "C"
	}
}

func total(marks ...int) int {
	t := 0
	for _, m := range marks {
		t += m
	}
	return t
}

func main() {
	for _, m := range []int{95, 80, 60} {
		fmt.Print(grade(m), " ")
	}
	fmt.Println(total(10, 20, 30))
}

A B C 60

Packages and Modules

String Methods

The strings functions you will use most:

Also remember:

• len(s) counts bytes. utf8.RuneCountInString(s) counts characters.
• s[1:4] cuts bytes 1 to 3.
• For many joins, use strings.Builder: b.WriteString("x"), then b.String().

String Formatting

The fmt verbs:

Functions: Println (spaces and new line), Printf (verbs), Sprintf (returns the string), Errorf (returns an error).

Date and Time

Reference date = Mon Jan 2 15:04:05 2006. Remember it as 1 2 3 4 5 6: month 1, day 2, hour 3 (15), minute 4, second 5, year 6.

Strings and time

package main

import (
	"fmt"
	"strings"
	"time"
)

func main() {
	parts := strings.Split("Asha,8A,91", ",")
	fmt.Println(strings.ToUpper(parts[0]), len(parts))
	exam := time.Date(2025, time.March, 14, 9, 30, 0, 0, time.UTC)
	fmt.Println(exam.Add(3 * time.Hour).Format("02/01/2006 15:04"))
}

ASHA 3
14/03/2025 12:30

Collections

len(x) works on arrays, slices, maps, strings and channels. cap(s) tells how much room a slice has.

Pointers and Structs

Interfaces and Generics

Structs, interfaces and generics

package main

import (
	"fmt"
	"sort"
)

type Shape interface{ Area() float64 }

type Rect struct{ W, H float64 }

func (r Rect) Area() float64 { return r.W * r.H }

type Square struct{ S float64 }

func (s Square) Area() float64 { return s.S * s.S }

func Largest[T int | float64](xs []T) T {
	best := xs[0]
	for _, x := range xs {
		if x > best {
			best = x
		}
	}
	return best
}

func main() {
	shapes := []Shape{Rect{2, 3}, Square{4}, Rect{1, 5}}
	sort.Slice(shapes, func(i, j int) bool { return shapes[i].Area() < shapes[j].Area() })
	var areas []float64
	for _, s := range shapes {
		areas = append(areas, s.Area())
	}
	fmt.Println(areas, Largest(areas))
}

[5 6 16] 16

Error Handling

File Handling

JSON

Only exported (capital) fields go into JSON.

Errors, files and JSON

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io/fs"
	"os"
)

type Config struct {
	School string `json:"school"`
	Year   int    `json:"year"`
}

func main() {
	_, err := os.ReadFile("missing.txt")
	fmt.Println(errors.Is(err, fs.ErrNotExist))

	data, _ := os.ReadFile("data/config.json")
	var c Config
	if err := json.Unmarshal(data, &c); err != nil {
		fmt.Println(err)
		return
	}
	out, _ := json.Marshal(c)
	fmt.Println(string(out))
}

true
{"school":"Green Valley School","year":2025}

Goroutines, Channels and Synchronization

The concurrency pieces and their jobs:

Reflection and Context

Goroutines, channels and context

package main

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

func main() {
	results := make(chan int, 3)
	var wg sync.WaitGroup
	for i := 1; i <= 3; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			results <- i * i
		}()
	}
	wg.Wait()
	close(results)
	sum := 0
	for r := range results {
		sum += r
	}
	fmt.Println("sum of squares:", sum)

	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
	defer cancel()
	select {
	case <-time.After(time.Second):
		fmt.Println("finished")
	case <-ctx.Done():
		fmt.Println("stopped:", ctx.Err())
	}
}

sum of squares: 14
stopped: context deadline exceeded

$ go doc strings.TrimSpace
func TrimSpace(s string) string
    TrimSpace returns a slice of the string s, with all leading and trailing
    white space removed, as defined by Unicode.

TL;DR

1. Types = int, float64, string, bool, rune, slices, maps, structs, pointers.
2. Control flow = if, switch, one for loop, range.
3. Functions = many results, variadic, closures, defer.
4. Types with behaviour = methods, embedding, interfaces, generics.
5. Safety = errors as values, %w, errors.Is / errors.As.
6. Files = os.ReadFile, os.WriteFile, encoding/json.
7. Concurrency = go, WaitGroup, channels, select, Mutex, context.
8. Lookup = go doc.

Common mistakes

The most common mistakes from the whole course, in one place.

Check Yourself

Exercises

What to Remember

• Nobody remembers everything. Know a tool exists, and look up the spelling.
• go doc explains any package or function, with no internet.
• Every variable and import must be used, and { stays on the same line.
• Integer division drops the decimal part. Convert with float64() first.
• Store the result of append. Make a map before you write to it.
• range gives a copy. Change elements with list[i].
• Errors are values. Check every err, and wrap with %w.
• Capital first letter = exported: other packages and JSON can see it.
• Wait for every goroutine. Lock shared data. defer cancel() every context.

You have finished the Go course. Keep practising: build a small project, like a library manager or a marks reporter, using what you learned.