Стандартная библиотека — справочник

1. strings и bytes

Пакеты strings и bytes повторяют друг друга: первый работает со строками, второй — с []byte. Строки неизменяемы, поэтому функции возвращают новые значения; bytes дополнительно даёт буфер, который можно менять.

s := "key=value"

before, after, ok := strings.Cut(s, "=")
fmt.Println(before, after, ok) // key value true

rest, ok := strings.CutPrefix(s, "key=")
fmt.Println(rest, ok) // value true

for line := range strings.Lines("a\nb\n") {
    fmt.Print(line)
}

Builder собирает строку без квадратичных копирований, Reader даёт io.Reader над строкой, Replacer выполняет несколько замен за один проход. В bytes те же роли играют Buffer и Reader.

var b strings.Builder
b.Grow(32)
b.WriteString("id=")
b.WriteString("42")
s := b.String()

2. strconv

ParseInt(s, base, bitSize): base от 2 до 36 или 0 — тогда основание определяется по префиксу (0x, 0o, 0b). bitSize ограничивает результат: 0 — int, 8/16/32/64 — соответствующий размер. FormatFloat принимает формат 'f', 'e', 'E', 'g', 'G', 'x'.

n, err := strconv.Atoi("42")
if err != nil {
    return err
}

hex := strconv.FormatInt(int64(n), 16) // "2a"
f, _ := strconv.ParseFloat("3.14", 64)
s := strconv.FormatFloat(f, 'f', 2, 64) // "3.14"

3. fmt

Флаги: + — знак или имена полей, - — выравнивание влево, # — альтернативная форма, 0 — ведущие нули, пробел — пробел вместо плюса. Ширина и точность задаются как %8.2f или через *.

type User struct {
    ID   int
    Name string
}

u := User{ID: 7, Name: "Аня"}
fmt.Printf("%v\n", u)   // {7 Аня}
fmt.Printf("%+v\n", u)  // {ID:7 Name:Аня}
fmt.Printf("%#v\n", u)  // main.User{ID:7, Name:"Аня"}
fmt.Printf("%08d\n", 42) // 00000042

Семейства: Print/Printf/Println пишут в стандартный вывод, Sprint* возвращают строку, Fprint* пишут в io.Writer, Errorf создаёт ошибку, Scan* читают ввод.

4. io, io/fs, bufio

io задаёт интерфейсы потоков. Чем меньше интерфейс, тем легче его реализовать и подменить в тестах.

Ошибки: io.EOF — штатный конец потока; io.ErrUnexpectedEOF — поток кончился раньше, чем ожидалось; io.ErrShortWrite — записано меньше, чем просили.

io/fs — абстракция файловой системы: fs.FS, fs.File, fs.DirEntry, fs.FileInfo. Функции fs.ReadFile, fs.ReadDir, fs.WalkDir, fs.Glob, fs.Sub, fs.ValidPath. Обход останавливают fs.SkipDir и fs.SkipAll.

bufio добавляет буфер: Reader с ReadString, ReadBytes, Peek, Scanner с Scan/Text/Bytes и функциями разбиения ScanLines, ScanWords, ScanRunes, ScanBytes.

f, err := os.Open("data.txt")
if err != nil {
    return err
}
defer f.Close()

sc := bufio.NewScanner(f)
sc.Buffer(make([]byte, 64*1024), 1024*1024)
for sc.Scan() {
    fmt.Println(sc.Text())
}
if err := sc.Err(); err != nil {
    return err
}

5. os, os/exec, path/filepath

os.Root ограничивает операции каталогом: пути, ведущие наружу, включая символические ссылки, запрещены. Это защита от обхода каталога, когда часть пути приходит извне.

root, err := os.OpenRoot("/srv/uploads")
if err != nil {
    return err
}
defer root.Close()

f, err := root.Open("report.txt") // только внутри /srv/uploads
if err != nil {
    return err
}
defer f.Close()

os/exec запускает процессы: Command, CommandContext, Run, Output, CombinedOutput, StdoutPipe/StdinPipe, Start/Wait. Ошибку ненулевого кода возвращает *exec.ExitError; exec.LookPath ищет исполняемый файл в PATH.

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

cmd := exec.CommandContext(ctx, "git", "rev-parse", "HEAD")
out, err := cmd.Output()
if err != nil {
    return fmt.Errorf("git: %w", err)
}
fmt.Println(strings.TrimSpace(string(out)))

path/filepath работает с путями текущей ОС: Join, Clean, Abs, Base, Dir, Ext, Rel, Match, Glob, WalkDir, EvalSymlinks, ToSlash/FromSlash, Separator. Для URL-путей есть отдельный path.

6. time

time.Time — момент времени с часовым поясом; time.Duration — длительность в наносекундах. Now несёт монотонное показание, поэтому Sub и сравнения не зависят от перевода системных часов; форматирование монотонную часть отбрасывает.

Раскладка задаётся эталонным временем Mon Jan 2 15:04:05 MST 2006. Готовые константы: ANSIC, UnixDate, RFC822, RFC822Z, RFC850, RFC1123, RFC1123Z, RFC3339, RFC3339Nano, Kitchen, Stamp, StampMilli, StampMicro, StampNano, DateTime [1.20], DateOnly [1.20], TimeOnly [1.20].

t, err := time.Parse(time.RFC3339, "2026-11-04T10:30:00Z")
if err != nil {
    return err
}

fmt.Println(t.Format(time.DateOnly)) // 2026-11-04

ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for range ticker.C {
    break
}

time.After в цикле создаёт новый таймер на каждой итерации; NewTimer с Reset переиспользует один. Ticker и Timer нужно останавливать, иначе они живут до срабатывания.

7. encoding/json

Теги полей: json:"name", json:"-" — исключить, omitempty — пропустить пустое, omitzero [1.24] — пропустить нулевое (в том числе нулевой time.Time), string — закодировать число или bool строкой.

type User struct {
    ID        int       `json:"id"`
    Name      string    `json:"name"`
    Email     string    `json:"email,omitempty"`
    CreatedAt time.Time `json:"created_at,omitzero"`
}

data, err := json.Marshal(User{ID: 1, Name: "Аня"})
if err != nil {
    return err
}
fmt.Println(string(data)) // {"id":1,"name":"Аня"}

Decoder.DisallowUnknownFields запрещает лишние поля, UseNumber сохраняет числа как json.Number, More и Token позволяют читать поток токенов. Encoder.SetEscapeHTML(false) отключает экранирование <, > и &; по умолчанию оно включено.

dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()

var req CreateUser
if err := dec.Decode(&req); err != nil {
    return fmt.Errorf("decode: %w", err)
}

8. net/http

Пакет даёт и клиент, и сервер. Устройство запроса, middleware, таймауты и завершение разобраны в листе «HTTP-сервис»; здесь — карта API.

С Go 1.22 шаблоны ServeMux принимают метод и подстановки: "GET /users/{id}", значение — r.PathValue("id"). Шаблон с методом приоритетнее шаблона без метода; {$} требует точного совпадения пути.

mux := http.NewServeMux()
mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")
    fmt.Fprintf(w, "user %s", id)
})

srv := &http.Server{
    Addr:              ":8080",
    Handler:           mux,
    ReadHeaderTimeout: 5 * time.Second,
}
log.Fatal(srv.ListenAndServe())

Клиент без таймаута может ждать вечно; таймаут задают на Client или через контекст запроса. Transport переиспользует соединения, поэтому создавать новый Client на каждый запрос не нужно.

client := &http.Client{Timeout: 5 * time.Second}

req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
    return err
}

resp, err := client.Do(req)
if err != nil {
    return err
}
defer resp.Body.Close()

9. log/slog

log/slog (Go 1.21) — структурное логирование: запись состоит из сообщения и набора пар «ключ — значение». Обработчик (Handler) решает, в каком формате и куда писать.

var level slog.LevelVar
level.Set(slog.LevelInfo)

h := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level:     &level,
    AddSource: true,
})
log := slog.New(h).With("service", "billing")

log.Info("started", "addr", ":8080")
log.Error("request failed", "err", err, "user_id", 42)

Уровни: Debug, Info, Warn, Error. Контекстные варианты InfoContext и подобные передают context.Context обработчику, который может достать из него трассировку или идентификатор запроса.

10. slices, maps, cmp, sort

Пакеты slices и maps (Go 1.21) — обобщённые операции над срезами и мапами. С Go 1.23 часть функций возвращает итераторы iter.Seq, которые работают в for range.

nums := []int{3, 1, 2}
slices.Sort(nums)                 // [1 2 3]
fmt.Println(slices.Contains(nums, 2))

people := []Person{{"Аня", 30}, {"Борис", 25}}
slices.SortFunc(people, func(a, b Person) int {
    return cmp.Compare(a.Age, b.Age)
})

m := map[string]int{"b": 2, "a": 1}
keys := slices.Sorted(maps.Keys(m)) // [a b]

sort.Slice принимает функцию сравнения по индексам и работает через отражение; для типизированных срезов slices.SortFunc быстрее и безопаснее по типам.

11. embed

Директива //go:embed встраивает файлы в бинарник. Переменная может быть string, []byte или embed.FS; для каталога — только embed.FS.

Шаблон не может содержать ., .. или начинаться с /. Файлы, начинающиеся с . или _, по умолчанию пропускаются — их включает префикс all:.

import "embed"

//go:embed static
var static embed.FS

func main() {
    sub, err := fs.Sub(static, "static")
    if err != nil {
        log.Fatal(err)
    }
    http.Handle("/", http.FileServer(http.FS(sub)))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

embed.FS реализует fs.FS, поэтому его можно отдать в http.FS, template.ParseFS или fs.WalkDir.

12. Первоисточники

• pkg.go.dev/strings и pkg.go.dev/bytes
• pkg.go.dev/strconv
• pkg.go.dev/fmt
• pkg.go.dev/io, pkg.go.dev/io/fs, pkg.go.dev/bufio
• pkg.go.dev/os, pkg.go.dev/os/exec, pkg.go.dev/path/filepath
• pkg.go.dev/time
• pkg.go.dev/encoding/json
• pkg.go.dev/net/http
• pkg.go.dev/log/slog
• pkg.go.dev/slices, pkg.go.dev/maps, pkg.go.dev/cmp, pkg.go.dev/sort
• pkg.go.dev/embed
• Release notes Go 1.24 — os.Root, omitzero, итераторы strings и bytes
• Release notes Go 1.25 — http.CrossOriginProtection
• Release notes Go 1.27 — strings.CutLast, bytes.CutLast