Книги
Go
Розділ 5. Хороші практики програмування
Організація коду за допомогою функцій

Go:
Організація коду за допомогою функцій

Як це зробити:

У Go ви визначаєте функцію, використовуючи ключове слово func, за яким слідує назва функції, параметри (якщо такі є) та тип повернення. Давайте проілюструємо на простому прикладі:

package main

import "fmt"

// визначаємо функцію для обчислення суми двох чисел
func addNumbers(a int, b int) int {
    return a + b
}

func main() {
    sum := addNumbers(5, 7)
    fmt.Println("Сума це:", sum)
    // Вивід: Сума це: 12
}

Функції також можуть повертати кілька значень, що є унікальною особливістю порівняно з багатьма іншими мовами. Ось як ви можете цим скористатися:

// визначаємо функцію для обміну двох чисел
func swap(a, b int) (int, int) {
    return b, a
}

func main() {
    x, y := swap(10, 20)
    fmt.Println("x, y після обміну:", x, y)
    // Вивід: x, y після обміну: 20 10
}

Ви також можете визначити функції зі змінною кількістю аргументів, використовуючи еліпсу ... перед типом параметра. Це корисно для створення гнучких функцій:

// визначаємо функцію для обчислення суми невідомої кількості цілих чисел
func sum(numbers ...int) int {
    total := 0
    for _, number := range numbers {
        total += number
    }
    return total
}

func main() {
    total := sum(1, 2, 3, 4, 5)
    fmt.Println("Загальна сума це:", total)
    // Вивід: Загальна сума це: 15
}

Підводне каміння

Концепція організації коду у функції не є унікальною для Go — це фундаментальний принцип програмування. Однак, Go вводить певні конвенції та можливості, які відрізняють його управління функціями. Наприклад, можливість повертати кілька значень із функцій є відносно унікальною та може призвести до чистішого, більш зрозумілого коду, особливо коли йдеться про операції, які можуть традиційно вимагати використання вказівників або обробки виключень.

Більш того, підтримка Go першокласних функцій — функції, які можна передавати як аргументи в інші функції, повертати як значення з функцій та призначати для змінних — підсилює підтримку мовою патернів функціонального програмування. Ця особливість особливо корисна при створенні функцій вищого порядку, які маніпулюють або поєднують інші функції.

Однак важливо бути уважним до “закону зменшення прибутку” при організації коду у функції. Надмірна модуляризація може призвести до надмірної абстракції, роблячи код важчим для розуміння та підтримки. Більш того, хоча спрощений підхід Go до обробки помилок (повернення помилок як нормальних значень повернення) спонукає до чистої пропагації помилок через декілька рівнів викликів функцій, це може призвести до повторюваного коду обробки помилок. Альтернативи, такі як фреймворки обробки помилок або впровадження підходу “try-catch” з інших мов (хоча і не підтримується вроджено) через пакетні імплементації, іноді можуть запропонувати більш елегантні рішення залежно від конкретного випадку.

Рішення про те, наскільки широко використовувати функції та модуляризацію в Go, має забезпечувати баланс між потребою в абстракції, легкістю підтримки, продуктивністю та зрозумілим обробленням помилок, максимально використовуючи прості, але потужні можливості Go.

ЛогуванняРефакторинг