Есть ли в Go перегрузка функций и методов как в Java/C++?

Почему в Go нет перегрузки функций?

Вы абсолютно правы: в Go действительно нет перегрузки функций и методов в классическом понимании (как в Java, C++ или C#). Это сознательное решение разработчиков языка. Причина — простота и читаемость кода. Перегрузка может приводить к путанице: какой именно метод вызовется, особенно если параметры имеют схожие типы (например, int и int64). В Go код должен быть максимально явным.

Ошибка, которую вы получили (redeclared in this block), — это прямое следствие этого правила. В одной области видимости (пакете) не может быть двух функций с одинаковым именем, даже если у них разные параметры.

Как решать задачу "одна операция — разные типы"?

В Go для этого есть три основных подхода. Рассмотрим их на примере нашей задачи с функцией print.

1. Разные имена (самый простой и идиоматичный способ)

Просто дайте функциям разные, но понятные имена. Это не нарушает DRY, а наоборот — делает код самодокументируемым.

package main

import "fmt"

func printString(s string) {
    fmt.Println("String:", s)
}

func printInt(i int) {
    fmt.Println("Int:", i)
}

func main() {
    printString("hello")
    printInt(42)
}

В стандартной библиотеке Go этот подход используется повсеместно. Например, пакет json содержит функции Marshal, Unmarshal, MarshalIndent — и никакой перегрузки.

2. Интерфейсы (для функций, работающих с любым типом)

Если вам нужно, чтобы функция принимала любой тип, используйте пустой интерфейс interface{} (в Go 1.18+ — any) в сочетании с type switch.

package main

import "fmt"

func printAny(v interface{}) {
    switch val := v.(type) {
    case string:
        fmt.Println("String:", val)
    case int:
        fmt.Println("Int:", val)
    case float64:
        fmt.Println("Float:", val)
    default:
        fmt.Println("Unknown type:", val)
    }
}

func main() {
    printAny("hello")
    printAny(42)
    printAny(3.14)
}

Важно: Это не перегрузка в классическом смысле. Это одна функция, которая ведёт себя по-разному в зависимости от типа аргумента во время выполнения (runtime).

3. Дженерики (Go 1.18+) — современный и типобезопасный способ

Если вы используете Go 1.18 или новее, можно применить обобщённое программирование (дженерики). Это позволяет писать одну функцию для разных типов, но с проверкой на этапе компиляции.

package main

import "fmt"

// Обобщённая функция, работает с любым типом, поддерживающим fmt.Stringer
func printGeneric[T fmt.Stringer](v T) {
    fmt.Println(v.String())
}

// Но для простых типов (int, string) нужно использовать constraints
func printAnyType[T any](v T) {
    fmt.Println(v)
}

func main() {
    printAnyType("hello")
    printAnyType(42)
}

Дженерики — это мощный инструмент, но не злоупотребляйте им. Для простых случаев (2-3 разных типа) лучше использовать разные имена или интерфейсы.

Что выбрать?

• Разные имена — для функций с разной семантикой (например, SaveToFile и SaveToDB).
• Интерфейсы + type switch — когда функция должна обрабатывать ограниченный набор заранее известных типов.
• Дженерики — когда алгоритм одинаков для многих типов (например, сортировка, поиск, математические операции).

В вашем случае с функцией print самый простой и правильный путь — использовать разные имена (printString, printInt) или сразу fmt.Println, который и так умеет работать с любыми типами.

package main

import "fmt"

func printAll(vals ...interface{}) {
    for _, v := range vals {
        switch val := v.(type) {
        case string:
            fmt.Printf("String: %s\n", val)
        case int:
            fmt.Printf("Int: %d\n", val)
        default:
            fmt.Printf("Unknown: %v\n", val)
        }
    }
}

func main() {
    printAll("hello", 42, 3.14, true)
}