Часть 3. Данные и памятьУрок 12# go# функции# замыкания

Продвинутые функции

вариативные и анонимные функции, замыкания, callbacks

Цели главы

  • Писать вариативные функции и передавать в них слайсы.
  • Объявлять анонимные функции, вызывать их сразу и хранить в переменных.
  • Понимать замыкания и писать генераторы и фабрики функций.
  • Передавать функции как callbacks и писать функции высшего порядка.

Вариативные функции

Нужны, когда число аргументов заранее неизвестно. Три точки перед типом последнего параметра означают «здесь может быть 0, 1, 2 или сколько угодно аргументов этого типа». Внутри функции такой параметр — обычный слайс: у него есть длина, по нему можно пройти циклом. Чтобы передать готовый слайс, его разворачивают тремя точками: averageRating(userRatings...).

go
package main

import "fmt"

// averageRating считает среднее из любого числа оценок.
func averageRating(ratings ...float64) float64 {
    if len(ratings) == 0 {
        return 0
    }
    sum := 0.0
    for _, r := range ratings {
        sum += r
    }
    return sum / float64(len(ratings))
}

func main() {
    fmt.Printf("%.1f\n", averageRating(8.0, 9.2, 7.5))
    fmt.Printf("%.1f\n", averageRating(9.0))
    fmt.Printf("%.1f\n", averageRating())

    userRatings := []float64{8.2, 7.8, 9.1, 8.5}
    fmt.Printf("%.1f\n", averageRating(userRatings...)) // слайс разворачиваем через ...
}
stdout // вывод программы
8.2
9.0
0.0
8.4

Вариативный параметр — последний

Перед вариативным параметром может быть сколько угодно обычных. Для аргументов разных типов используют ...any — так устроен и fmt.Println. Встроенный append — тоже вариативная функция.

go
package main

import "fmt"

func showVariadicInfo(ratings ...float64) {
    fmt.Printf("тип: %T, длина: %d, содержимое: %v\n", ratings, len(ratings), ratings)
}

func addToPlaylist(name string, movies ...string) {
    if len(movies) == 0 {
        fmt.Printf("%s: пусто\n", name)
        return
    }
    fmt.Printf("%s: %v\n", name, movies)
}

func debugPrint(args ...any) {
    for i, arg := range args {
        fmt.Printf("[%d] %v (%T)\n", i, arg, arg)
    }
}

func main() {
    showVariadicInfo(7.0, 8.5, 9.1)
    addToPlaylist("Мой плейлист", "Матрица", "Начало", "Дюна")
    addToPlaylist("Пустой плейлист")
    debugPrint("Гладиатор", 2000, 8.6, true)

    films := []string{"A"}
    films = append(films, "B", "C")
    extra := []string{"D", "E"}
    films = append(films, extra...)
    fmt.Println(films)
}
stdout // вывод программы
тип: []float64, длина: 3, содержимое: [7 8.5 9.1]
Мой плейлист: [Матрица Начало Дюна]
Пустой плейлист: пусто
[0] Гладиатор (string)
[1] 2000 (int)
[2] 8.6 (float64)
[3] true (bool)
[A B C D E]

Три ошибки новичков

Во всех трёх случаях код не скомпилируется:

Ошибка Пример Что скажет компилятор
Вариативный параметр не последний func f(a ...int, b string) can only use ... with final parameter
Забыл развернуть слайс averageRating(userRatings) cannot use userRatings (variable of type []float64) as float64 value in argument to averageRating
Два вариативных параметра func f(a ...int, b ...string) can only use ... with final parameter

Анонимные функции

Анонимная функция — функция без имени, объявленная через func. Её можно:

  • вызвать сразу — круглые скобки после тела. Это IIFE (Immediately Invoked Function Expression, немедленно вызываемое функциональное выражение);
  • сохранить в переменную и вызвать позже — и даже переназначить на другую функцию того же типа.
go
package main

import (
    "fmt"
    "strings"
)

func main() {
    func() {
        fmt.Println("Привет из анонимной функции!")
    }() // скобки в конце — немедленный вызов

    func(title string) {
        fmt.Println("Показываем:", title)
    }("Гладиатор")

    formatMovie := func(title string, year int) string {
        return fmt.Sprintf("%s (%d)", title, year)
    }
    fmt.Println(formatMovie("Матрица", 1999))

    formatMovie = func(title string, year int) string { // переназначили
        return fmt.Sprintf("[%d] %s", year, strings.ToUpper(title))
    }
    fmt.Println(formatMovie("Дюна", 2021))
}
stdout // вывод программы
Привет из анонимной функции!
Показываем: Гладиатор
Матрица (1999)
[2021] ДЮНА

Замыкания

Замыкание (closure) — функция, которая захватывает переменные из окружающего кода. Захватывается сама переменная, а не копия её значения, поэтому изменения видны снаружи. Аналогия: в комнате на стене висит табло со счётом. Замыкание — человек в этой комнате: он видит табло и может менять счёт, и все изменения видны всем.

Классический пример — генератор уникальных ID. Каждый вызов makeIDGenerator создаёт свою переменную counter, поэтому у разных генераторов независимые счётчики.

go
package main

import "fmt"

func makeIDGenerator(prefix string) func() string {
    counter := 0 // у каждого генератора свой счётчик
    return func() string {
        counter++
        return fmt.Sprintf("%s-%d", prefix, counter)
    }
}

func main() {
    watchCount := 0
    watchMovie := func(title string) {
        watchCount++ // замыкание меняет внешнюю переменную
        fmt.Printf("Просмотр #%d: %s\n", watchCount, title)
    }
    watchMovie("Гладиатор")
    watchMovie("Начало")
    fmt.Println("Всего:", watchCount)

    newMovieID := makeIDGenerator("FILM")
    newUserID := makeIDGenerator("USER")
    fmt.Println(newMovieID(), newMovieID(), newUserID())
}
stdout // вывод программы
Просмотр #1: Гладиатор
Просмотр #2: Начало
Всего: 2
FILM-1 FILM-2 USER-1

Callbacks и функции высшего порядка

Callback — функция, которую передают аргументом в другую функцию, чтобы та вызвала её позже. Яркий пример — sort.Slice: ему передают правило сравнения, и оно вызывается внутри сортировки. Функция высшего порядка — функция, которая принимает или возвращает другую функцию.

go
package main

import (
    "cmp"
    "fmt"
    "slices"
    "sort"
    "strings"
    "time"
    "unicode/utf8"
)

// makeDiscountApplier возвращает функцию, применяющую скидку.
func makeDiscountApplier(rate float64) func(float64) float64 {
    return func(price float64) float64 {
        return price * (1 - rate)
    }
}

// transformStrings применяет функцию к каждой строке.
func transformStrings(items []string, fn func(string) string) []string {
    result := make([]string, len(items))
    for i, item := range items {
        result[i] = fn(item)
    }
    return result
}

// benchmarkOperation замеряет время выполнения переданной функции.
func benchmarkOperation(op func()) time.Duration {
    start := time.Now()
    op()
    return time.Since(start)
}

func main() {
    ratings := []float64{7.2, 9.1, 6.5, 8.8, 5.3}
    sort.Slice(ratings, func(i, j int) bool {
        return ratings[i] > ratings[j] // по убыванию
    })
    fmt.Println(ratings)

    films := []string{"Матрица", "Дюна", "Начало"}
    slices.SortFunc(films, func(a, b string) int {
        return cmp.Compare(utf8.RuneCountInString(a), utf8.RuneCountInString(b)) // по длине названия
    })
    fmt.Println(films)

    applyDiscount := makeDiscountApplier(0.20)
    fmt.Printf("%.2f\n", applyDiscount(1000))

    fmt.Println(transformStrings([]string{"матрица", "дюна"}, strings.ToUpper))

    d := benchmarkOperation(func() { time.Sleep(20 * time.Millisecond) })
    fmt.Println(d >= 20*time.Millisecond)
}
stdout // вывод программы
[9.1 8.8 7.2 6.5 5.3]
[Дюна Начало Матрица]
800.00
[МАТРИЦА ДЮНА]
true
  • makeDiscountApplier — фабрика функций: возвращает функцию, которая запомнила ставку скидки.
  • transformStrings принимает функцию и применяет её к каждому элементу — сюда можно передать даже готовую strings.ToUpper.
  • benchmarkOperation засекает время, запускает переданную функцию и возвращает time.Since(start).

Итоги

Вариативные функции: принимают 0 и более аргументов; внутри — слайс; передавая слайс, распаковывай его тремя точками; популярные примеры — append и fmt.Println.

Анонимные функции и замыкания: функцию без имени можно вызвать сразу или сохранить в переменную; замыкание захватывает переменную окружения и меняет её; на этом построены генераторы, callbacks и фабрики функций.

Практика

  1. Напиши вариативную sumAll(nums ...int) int и вызови её с литералами, без аргументов и со слайсом длительностей фильмов.
  2. Напиши фабрику makeMultiplier(k int) func(int) int и создай с её помощью double и triple.
  3. Напиши filter(items []string, keep func(string) bool) []string и отбери фильмы на букву «Д», передав анонимную функцию.
решениеЭталонное решение
go
package main

import (
    "fmt"
    "strings"
)

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

func makeMultiplier(k int) func(int) int {
    return func(x int) int { return x * k }
}

func filter(items []string, keep func(string) bool) []string {
    var result []string
    for _, item := range items {
        if keep(item) {
            result = append(result, item)
        }
    }
    return result
}

func main() {
    durations := []int{148, 169, 155}
    fmt.Println(sumAll(1, 2, 3), sumAll(), sumAll(durations...))

    double, triple := makeMultiplier(2), makeMultiplier(3)
    fmt.Println(double(5), triple(5))

    films := []string{"Дюна", "Довод", "Матрица", "Начало"}
    fmt.Println(filter(films, func(title string) bool {
        return strings.HasPrefix(title, "Д")
    }))
}
stdout // вывод программы
6 0 472
10 15
[Дюна Довод]

Тренировка: предскажи вывод

go
package main

import "fmt"

func counter() func() int {
    n := 0
    return func() int {
        n++
        return n
    }
}

func main() {
    a := counter()
    b := counter()
    fmt.Println(a(), a(), b(), a())
}
самопроверкаОтвет
text
1 2 1 3

У a и b разные переменные n: каждый вызов counter() создаёт новую. Аргументы Println вычисляются слева направо.

Проверь себя

вопросЧто такое вариативная функция и что лежит внутри её вариативного параметра?

Функция с последним параметром ...T, принимающая любое число аргументов типа T. Внутри параметр — обычный слайс []T.

вопросКак передать готовый слайс в вариативную функцию?

Развернуть его тремя точками: f(s...).

самопроверкаНазови три ошибки при работе с вариативными функциями.

Вариативный параметр не последний; слайс передан без ...; объявлено два вариативных параметра.

вопросЧто такое IIFE?

Немедленно вызываемая анонимная функция: func() { … }().

вопросЧто такое замыкание и что оно захватывает — копию или переменную?

Функция, которая использует переменные из окружающей области видимости. Захватывается сама переменная, поэтому изменения видны снаружи и сохраняются между вызовами.

самопроверкаЧто такое функция высшего порядка? Приведи пример из стандартной библиотеки.

Функция, которая принимает или возвращает другую функцию. Пример — sort.Slice или slices.SortFunc, принимающие функцию сравнения.


Ключевые выводы

  • 🎛️ ...T — любое число аргументов; внутри это []T, слайс передают как s....
  • 🧷 Вариативный параметр всегда последний и может быть только один.
  • 🕶️ Анонимную функцию вызывают сразу (IIFE) или хранят в переменной.
  • 🔒 Замыкание захватывает переменную окружения, а не копию; у каждого вызова фабрики — свои переменные.
  • 🔁 С Go 1.22 переменная цикла новая на каждой итерации — замыкания видят своё значение.
  • 🧩 Callbacks и функции высшего порядка: sort.Slice, slices.SortFunc, фабрики и обёртки.
// связанные темы и шпаргалки