Karatasi ya Muhtasari ya Go
Rejeo la Go linalotafutika na kuchapishika: structs, slices, maps, interfaces, error wrapping, goroutines, channels, generics na go CLI. Bure.
Basics
10package main
Executable entry package
import ("fmt"; "os")
Import standard packages
x := 42
Short declare (inside funcs only)
var s string
Zero value: "" (0, nil, false)
const MaxRetries = 3
Typed or untyped constant
const (A = iota; B; C)
Auto-incrementing enum values
a, b = b, a
Multiple assignment / swap
_, err := doWork()
Blank identifier discards values
fmt.Println("hi"); fmt.Printf("%v\n", x)
Print values (%v = default)
fmt.Sprintf("%s-%d", name, id)
Format into a string
Types, structs & methods
10type User struct { Name string; Age int }
Struct definition
u := User{Name: "Sam", Age: 30}
Struct literal (named fields)
u.Name = "Alex"
Field access / mutation
func (u User) Label() string
Value receiver (reads only)
func (u *User) Rename(n string)
Pointer receiver (mutates)
func NewUser(n string) *User
Constructor function idiom
type Admin struct { User; Level int }
Embedding: fields promoted
type UserID int
Named type (own method set)
Name string `json:"name,omitempty"`
Struct tag for encoding
p := &User{}; p.Name = "x"
Auto-deref through pointers
Slices & maps
13s := []int{1, 2, 3}
Slice literal
s = make([]int, 0, 10)
Empty slice with capacity 10
s = append(s, 4, 5)
Append (reassign the result)
n := copy(dst, src)
Copy elements between slices
s[1:3]
Sub-slice (shares the array)
len(s), cap(s)
Length and capacity
var s []int; s = append(s, 1)
Appending to nil is fine
m := map[string]int{"a": 1}
Map literal
v, ok := m["key"]
Lookup with existence check
delete(m, "key")
Remove a key
for k, v := range m { ... }
Iterate (order is random)
slices.Contains(s, 3)
Search helper (Go 1.21+)
slices.Sort(s); maps.Keys(m)
slices / maps packages
Control flow
10for i := 0; i < n; i++ { ... }
Classic for (the only loop)
for i, v := range items { ... }
Index + value iteration
for cond { ... }
While-style loop
for { ... }
Infinite loop (break to exit)
for i := range 10 { ... }
Range over int (Go 1.22+)
if err := load(); err != nil { ... }
If with init statement
switch status { case "on": ... default: ... }
No fallthrough by default
switch { case n > 10: ... }
Condition-less switch chain
switch v := x.(type) { case int: ... }
Type switch
outer: for { break outer }
Labeled break / continue
Functions & defer
9func add(a, b int) int { return a + b }
Basic function
func load() ([]byte, error)
Multiple return values
func div(a, b int) (q int, err error)
Named return values
func sum(ns ...int) int
Variadic; call sum(s...)
defer f.Close()
Run at function exit
defer mu.Unlock() // LIFO order
Multiple defers run in reverse
counter := func() int { n++; return n }
Closure captures variables
type Handler func(w, r)
Function type declaration
apply(items, strings.ToUpper)
Functions are first-class values
Interfaces & type assertions
10type Stringer interface { String() string }
Interface: a method set
// no "implements" keyword
Satisfaction is implicit
io.Reader / io.Writer
The ubiquitous stream duo
var x any = 42
any = interface{} (anything)
s, ok := x.(string)
Type assertion (safe form)
switch v := x.(type) { case string: ... }
Branch by dynamic type
type ReadCloser interface { Reader; Closer }
Interface embedding
func Save(w io.Writer, u User) error
Accept interfaces...
func NewStore() *Store
...return concrete structs
var _ Stringer = (*User)(nil)
Compile-time conformance check
Error handling
10if err != nil { return err }
The fundamental pattern
errors.New("not found")
Simple error value
fmt.Errorf("load %s: %w", path, err)
Wrap with context (%w)
errors.Is(err, os.ErrNotExist)
Match a sentinel in the chain
var pe *fs.PathError; errors.As(err, &pe)
Extract a typed error
var ErrNotFound = errors.New("not found")
Exported sentinel error
func (e *ValidationError) Error() string
Custom error type
errors.Join(err1, err2)
Combine multiple errors
defer func() { recover() }()
Recover from a panic
panic("unreachable")
Only for programmer errors
Goroutines & channels
12go work()
Start a goroutine
ch := make(chan int)
Unbuffered (synchronous) channel
ch := make(chan int, 10)
Buffered channel
ch <- v / v := <-ch
Send / receive
close(ch); for v := range ch { ... }
Drain until closed
select { case v := <-a: ... case b <- x: ... }
Wait on multiple channels
var wg sync.WaitGroup; wg.Add(1); wg.Wait()
Wait for goroutines
defer wg.Done()
Signal completion
for job := range jobs { results <- run(job) }
Worker pool body
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
Deadline for downstream work
select { case <-ctx.Done(): return ctx.Err() }
Abort on cancellation
var mu sync.Mutex; mu.Lock(); defer mu.Unlock()
Guard shared state
Generics
9func Map[T, U any](s []T, f func(T) U) []U
Generic function
func Keys[K comparable, V any](m map[K]V) []K
comparable: map-key types
type Number interface { ~int | ~float64 }
Union constraint (~ = derived)
func Sum[T Number](ns []T) T
Use a custom constraint
type Stack[T any] struct { items []T }
Generic type
s := Stack[int]{}
Explicit instantiation
doubled := Map(nums, double)
Type args usually inferred
func Min[T cmp.Ordered](a, b T) T
cmp.Ordered: < > comparable
min(a, b), max(a, b)
Builtins since Go 1.21
Standard library gems
14strings.Split(s, ","); strings.Join(parts, "-")
Split and join
strings.Contains, HasPrefix, TrimSpace
Everyday string helpers
n, err := strconv.Atoi("42")
String → int (Itoa reverses)
time.Now(); time.Since(start)
Current time and elapsed
t.Format("2006-01-02 15:04")
Reference-date layout
time.Sleep(200 * time.Millisecond)
Pause the goroutine
data, err := os.ReadFile("cfg.json")
Read a whole file
os.WriteFile(path, data, 0o644)
Write a file with perms
os.Getenv("HOME"); filepath.Join(dir, f)
Env vars and safe paths
json.Marshal(v); json.Unmarshal(b, &v)
JSON encode / decode
resp, err := http.Get(url); defer resp.Body.Close()
HTTP client call
http.HandleFunc("/", h); http.ListenAndServe(":8080", nil)
Minimal HTTP server
slog.Info("started", "port", 8080)
Structured logging (1.21+)
sc := bufio.NewScanner(f); for sc.Scan()
Read input line by line
Testing & benchmarks
11func TestAdd(t *testing.T) { ... }
Test in *_test.go
t.Errorf("got %d, want %d", got, want)
Fail but keep running
t.Fatalf("setup failed: %v", err)
Fail and stop this test
tests := []struct{ in, want int }{...}
Table-driven test data
t.Run(tc.name, func(t *testing.T) {...})
Named subtests
t.Helper()
Blame the caller in failures
t.Parallel()
Run this test concurrently
func BenchmarkAdd(b *testing.B) { for range b.N { add(1, 2) } }
Benchmark loop
go test -bench=. -benchmem
Run benchmarks + allocations
go test -run TestAdd ./...
Run tests matching a pattern
go test -cover ./...
Coverage summary
Go CLI
11go mod init example.com/app
Start a new module
go mod tidy
Sync go.mod with imports
go get github.com/pkg/x@latest
Add / upgrade a dependency
go run .
Compile and run in one step
go build ./...
Build all packages
go test ./...
Test the whole module
go vet ./...
Static analysis for bugs
gofmt -w .
Format all source files
go install golang.org/x/tools/...@latest
Install a tool binary
GOOS=linux GOARCH=amd64 go build
Cross-compile
go doc strings.Split
Read docs in the terminal
Hakuna kipengele kinacholingana na “:q”.
Kuhusu Karatasi ya Muhtasari ya Go
Karatasi hii ya muhtasari ya Go inabana Go ya kimtindo kwenye ukurasa mmoja unaotafutika: misingi, aina, structs na methods, slices na maps, mtiririko wa udhibiti, functions na defer, interfaces na type assertions, ushughulikiaji wa makosa, goroutines na channels, generics, vito vya maktaba ya kawaida, majaribio na benchmarks, na mstari wa amri wa go.
Inalenga mambo ambayo wasanidi wa Go hutafuta badala ya kukariri: mbinu kamili ya slice ya kufuta kipengele, tofauti kati ya errors.Is na errors.As, taarifa ya select yenye muda wa kikomo, jaribio la table-driven, au amri ipi ya go hufanya nini, ikiwa na maelezo mafupi kwenye kila safu.
Karatasi ni bure na inafanya kazi upande wa mteja: chuja safu moja kwa moja kwa kisanduku cha utafutaji, ruka kati ya sehemu kwa jedwali la yaliyomo linalobaki juu, nakili kijisehemu chochote kwa mbofyo mmoja na chapisha ukurasa kuwa rejeo wakati unaandika msimbo.
Jinsi ya kutumia Karatasi ya Muhtasari ya Go
- Pitia sehemu kwa haraka, kuanzia Misingi na Slices & maps kupitia Goroutines & channels hadi Go CLI.
- Tafuta neno kuu kama channel, defer au errors.Is ili kuchuja kila safu moja kwa moja.
- Ruka hadi Interfaces au Generics unapohitaji sintaksia ya aina badala ya amri.
- Bofya kijisehemu au ikoni yake ya kunakili ili kunakili msimbo wa Go kwenye ubao wako wa kunakili.
- Chapisha karatasi ili kupata rejeo la Go la nje ya mtandao.
Maswali yanayoulizwa mara kwa mara
Sehemu kumi na mbili: misingi, aina na structs, slices na maps, mtiririko wa udhibiti, functions na defer, interfaces na type assertions, ushughulikiaji wa makosa, goroutines na channels, generics, mambo muhimu ya maktaba ya kawaida, majaribio na benchmarks, na go CLI.
Ndiyo. Sehemu maalum inashughulikia goroutines, channels zenye bafa na zisizo na bafa, select yenye muda wa kikomo, WaitGroup, Mutex na kughairi kwa context.
Ndiyo: vigezo vya aina, constraints, constraints za comparable na any, pamoja na functions na aina za jumla kila kimoja kina safu zake.
Ndiyo. Bofya kijisehemu chochote au ikoni yake ya kunakili inayojitokeza ukielekeza kipanya na kinatua kwenye ubao wako wa kunakili pamoja na uthibitisho mfupi.
Ndiyo, ni bure kabisa: linatafutika, linachapishika na linaonyeshwa kwenye kivinjari chako bila usajili.
Utafutaji maarufu
go cheat sheet
golang cheat sheet
rejeo la sintaksia ya go
go slices na maps
goroutines na channels
ushughulikiaji wa makosa katika go
amri za go cli
Unahitaji msaada?
Umepata tatizo na zana hii? Tujulishe timu yetu.