Goチートシート

全開発ツール

無料

検索・印刷可能なGoリファレンス。構造体、スライス、マップ、インターフェース、エラーラッピング、goroutine、チャネル、ジェネリクス、goコマンドを網羅。無料。

Basics

package 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

type 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

s := []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

for 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

func 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

type 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

if 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

go 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

func 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

strings.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

func 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

go 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

「:q」に一致する項目はありません。

Goチートシートについて

このGoチートシートは、慣用的なGoの書き方を1つの検索可能なページに凝縮しています。基礎、型、構造体とメソッド、スライスとマップ、制御フロー、関数とdefer、インターフェースと型アサーション、エラー処理、goroutineとチャネル、ジェネリクス、標準ライブラリの便利な機能、テストとベンチマーク、goコマンドラインです。

暗記するのではなく調べるようなことを中心にしています。要素を削除する正確なスライスの技、errors.Isとerrors.Asの違い、タイムアウト付きのselect文、テーブル駆動テスト、あるいはどのgoコマンドが何をするかなどを、各行に短い説明付きでまとめています。

このシートは無料でクライアント側で動作します。検索ボックスで行をリアルタイムに絞り込み、追従する目次でセクション間を移動し、任意のスニペットをワンクリックでコピーし、コーディング中の参照用にページを印刷できます。

Goチートシートの使い方

基礎とスライス・マップからgoroutineとチャネル、Go CLIまで、各セクションにざっと目を通します。
channel、defer、errors.Isなどのキーワードを検索して、すべての行をリアルタイムに絞り込みます。
コマンドではなく型の構文が必要な場合は、インターフェースまたはジェネリクスのセクションに移動します。
スニペットまたはそのコピーアイコンをクリックして、Goのコードをクリップボードにコピーします。
シートを印刷して、オフラインのGoリファレンスとして使います。

よくある質問

基礎、型と構造体、スライスとマップ、制御フロー、関数とdefer、インターフェースと型アサーション、エラー処理、goroutineとチャネル、ジェネリクス、標準ライブラリの見どころ、テストとベンチマーク、goのCLIの12セクションです。

はい。専用のセクションで、goroutine、バッファ付き・なしチャネル、タイムアウト付きのselect、WaitGroup、Mutex、contextによるキャンセルを扱っています。

含まれています。型パラメータ、制約、comparableやanyといった制約、ジェネリックな関数と型が、それぞれ独自の行で扱われています。

はい。どのスニペットでも、ホバー時に表示されるコピーアイコンをクリックすれば、簡単な確認表示とともにクリップボードにコピーされます。

はい、完全無料です。検索・印刷が可能で、登録不要でブラウザ内に表示されます。

Goチートシート

Basics

Types, structs & methods

Slices & maps

Control flow

Functions & defer

Interfaces & type assertions

Error handling

Goroutines & channels

Generics

Standard library gems

Testing & benchmarks

Go CLI

Goチートシートについて

Goチートシートの使い方

よくある質問

Goチートシートには何が含まれていますか？

並行処理もカバーしていますか？

ジェネリクスも含まれていますか？

コードをワンクリックでコピーできますか？

Goリファレンスは無料ですか？

関連ツール

人気の検索

このツールを埋め込む