2.4 🛠 Функции

После изучения переменных и управляющих структур пора познакомиться с функциями — ключевым элементом любой программы на Go. Функции позволяют упаковывать код в многократно используемые блоки, делая программы более организованными и читаемыми.

💬 Что такое функция?
Функция — это именованный блок кода, который выполняет определённую задачу. Например, ты можешь создать функцию для вычисления суммы двух чисел или для вывода приветствия.

🔧 Объявление функции

Функции в Go объявляются с помощью ключевого слова func. Вот базовый синтаксис:

package main

import "fmt"

func имяФункции(параметры) возвращаемыйТип {
    // код функции
}

Пример:

package main

import "fmt"

func sayHello() {
    fmt.Println("Привет, Go!")
}

func main() {
    sayHello() // Вызов функции
}

💡 Функция main — это точка входа в программу. Она вызывается автоматически при запуске.

📥 Параметры функции

Функции могут принимать параметры — данные, с которыми они работают. Параметры указываются в скобках с их типами.

package main

import "fmt"

func add(a int, b int) {
    fmt.Println("Сумма:", a+b)
}

func main() {
    add(3, 5) // Сумма: 8
}

Если параметры одного типа, можно указать тип только для последнего:

func add(a, b int) {
    fmt.Println("Сумма:", a+b)
}

📤 Возвращаемые значения

Функции могут возвращать значения с помощью ключевого слова return. Тип возвращаемого значения указывается после параметров.

package main

import "fmt"

func multiply(x, y int) int {
    return x * y
}

func main() {
    result := multiply(4, 5)
    fmt.Println("Результат:", result) // Результат: 20
}

🔄 Множественный возврат

Go позволяет возвращать несколько значений из функции, что очень удобно, например, для обработки ошибок.

package main

import "fmt"

func divide(a, b int) (int, bool) {
    if b == 0 {
        return 0, false // Возвращаем 0 и false, если деление невозможно
    }
    return a / b, true
}

func main() {
    result, success := divide(10, 2)
    if success {
        fmt.Println("Результат деления:", result) // Результат деления: 5
    } else {
        fmt.Println("Деление на ноль!")
    }
}

⚠️ При получении нескольких значений нужно указать переменные для всех возвращаемых значений или использовать _ для игнорирования ненужных.

📋 Именованные возвращаемые значения

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

package main

import "fmt"

func subtract(a, b int) (result int) {
    result = a - b
    return // Автоматически возвращает result
}

func main() {
    fmt.Println(subtract(7, 3)) // 4
}

🛠 Практическое использование функций

Функции помогают:

• Упрощать код: Разбивайте сложную логику на маленькие функции.
• Повторно использовать код: Например, функцию sayHello можно вызывать многократно.
• Улучшать читаемость: Имена функций вроде add или divide говорят сами за себя.

Пример комбинированной программы:

package main

import "fmt"

func greet(name string) string {
    return "Привет, " + name + "!"
}

func sumAndDiff(a, b int) (sum, diff int) {
    sum = a + b
    diff = a - b
    return
}

func main() {
    fmt.Println(greet("Алиса")) // Привет, Алиса!
    
    s, d := sumAndDiff(10, 4)
    fmt.Println("Сумма:", s) // Сумма: 14
    fmt.Println("Разность:", d) // Разность: 6
}

📚 Полезные советы

• Имена функций: Используйте понятные имена, описывающие действие (например, calculateArea, а не ca).
• Короткие функции: Старайтесь, чтобы функции были небольшими и выполняли одну задачу.
• Ошибки: Используйте множественный возврат для обработки ошибок, как в примере с divide.
• Документация: Добавляйте комментарии перед функцией, чтобы объяснить её назначение.

🧠 Функции — это как инструменты в ящике: правильно подобранная функция делает код проще и эффективнее.

🧪 Пример программы

package main

import "fmt"

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func isEven(num int) (result bool) {
    result = num%2 == 0
    return
}

func main() {
    x, y := 15, 8
    fmt.Println("Максимум:", max(x, y)) // Максимум: 15
    
    if isEven(x) {
        fmt.Println(x, "— чётное")
    } else {
        fmt.Println(x, "— нечётное") // 15 — нечётное
    }
    
    result, ok := divide(10, 0)
    if ok {
        fmt.Println("Деление:", result)
    } else {
        fmt.Println("Ошибка: деление на ноль")
    }
}

func divide(a, b int) (int, bool) {
    if b == 0 {
        return 0, false
    }
    return a / b, true
}

🎭 Анонимные функции и замыкания

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

В Go можно создавать анонимные функции — функции без имени, которые можно объявлять прямо в коде и сразу использовать. Они особенно полезны для коротких операций, которые нужны только в одном месте, при работе с горутинами, как обработчики событий или для создания специализированных функций “на лету”:

func main() {
    // Анонимная функция, которая вызывается сразу
    func(message string) {
        fmt.Println("Анонимная функция:", message)
    }("Привет!")
    
    // Сохранение анонимной функции в переменную
    calculator := func(a, b int) int {
        return a * b
    }
    fmt.Printf("Результат: %d\n", calculator(5, 3))
}

Замыкания (Closures)

Замыкание — это анонимная функция, которая «захватывает» переменные из окружающей области видимости. Это мощная особенность Go, позволяющая создавать функции с “памятью”, идеально подходящие для создания конфигурируемых функций:

// Функция-фабрика, создающая счётчики
func createCounter(start int) func() int {
    count := start
    return func() int {
        count++ // Захватываем count
        return count
    }
}

func main() {
    counter1 := createCounter(0)
    counter2 := createCounter(100)
    
    fmt.Println("Счётчик 1:", counter1()) // 1
    fmt.Println("Счётчик 1:", counter1()) // 2
    fmt.Println("Счётчик 2:", counter2()) // 101
}

Практические применения

Анонимные функции и замыкания широко используются в современном Go для:

Обработки коллекций — применение операций к каждому элементу массива или слайса
Параллельного программирования — запуск горутин с минимальным количеством кода
Event handlers — обработка событий в веб-приложениях
Конфигурации — создание функций с предустановленными параметрами
Альтернативы ООП — создание объектов с состоянием без явных структур

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

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

// Функция, применяющая операцию к каждому элементу
func mapSlice(numbers []int, operation func(int) int) []int {
    result := make([]int, len(numbers))
    for i, num := range numbers {
        result[i] = operation(num)
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    
    // Применяем различные операции
    squares := mapSlice(numbers, func(x int) int { return x * x })
    doubled := mapSlice(numbers, func(x int) int { return x * 2 })
    
    fmt.Printf("Оригинал: %v\n", numbers)  // [1 2 3 4 5]
    fmt.Printf("Квадраты: %v\n", squares)   // [1 4 9 16 25]
    fmt.Printf("Удвоенные: %v\n", doubled) // [2 4 6 8 10]
}

Важные особенности

Захват по ссылке: Замыкания захватывают переменные по ссылке, что может привести к неожиданному поведению в циклах
Управление памятью: Замыкания могут удерживать ссылки на переменные, предотвращая сборку мусора
Производительность: Используйте в меру — чрезмерное вложение может снизить читаемость

🔍 Вопросы для самопроверки

1. Как объявить функцию в Go?
2. Что делает ключевое слово return?
3. Как вернуть несколько значений из функции?
4. Что такое именованные возвращаемые значения?
5. Как вызвать функцию greet с параметром "Боб"?
6. Почему полезно использовать функции в программах?
7. Что такое анонимная функция и когда её использовать?
8. Объясните концепцию замыкания на примере.
9. В чём разница между передачей функции как параметра и её вызовом?
10. Какие проблемы могут возникнуть при использовании замыканий в циклах?

📌 Главное из главы

• Функции в Go объявляются с помощью func и могут принимать параметры и возвращать значения
• Go поддерживает множественный возврат, что удобно для обработки ошибок
• Именованные возвращаемые значения упрощают код
• Анонимные функции позволяют создавать функции без имени прямо в коде
• Замыкания захватывают переменные из окружающей области видимости
• Функции высшего порядка принимают или возвращают другие функции
• Замыкания мощны, но требуют осторожности при захвате переменных в циклах
• Функции делают код модульным, читаемым и повторно используемым

🛠 Практические упражнения

Упражнение 1: Базовые функции

Напишите функцию square, которая принимает число n и возвращает его квадрат. Создайте также функцию isPositive, которая возвращает true для положительных чисел.

Упражнение 2: Множественный возврат

Создайте функцию divideWithRemainder, которая принимает два числа и возвращает результат деления и остаток. Обработайте случай деления на ноль.

Упражнение 3: Замыкания

Напишите функцию createMultiplier, которая принимает число factor и возвращает функцию, умножающую своё входное значение на factor. Создайте множители для 2, 3 и 10.

Упражнение 4: Функции высшего порядка

Реализуйте функцию reduce, которая принимает слайс чисел, начальное значение и функцию операции, возвращая итоговый результат. Используйте её для вычисления суммы и произведения чисел.

Упражнение 5: Продвинутые замыкания

Создайте функцию createBank, которая возвращает три функции: deposit (пополнить счёт), withdraw (снять деньги) и balance (проверить баланс). Все функции должны работать с одним общим балансом.