Как добавить новые методы к существующему типу в Go? (например, к int или string)

Создание псевдонима (type alias) или нового типа на основе существующего

В Go действительно нельзя добавлять методы к встроенным типам (int, string, float64 и т.д.) или типам из других пакетов (например, из стандартной библиотеки). Это фундаментальное ограничение языка, которое защищает инкапсуляцию и предотвращает конфликты. Однако Go предлагает элегантное решение: создание собственного типа на основе существующего.

Вместо того чтобы пытаться расширить int, вы объявляете новый тип MyInt с базовым типом int. Затем вы можете определить любые методы для этого нового типа. Это идиоматичный и рекомендуемый способ в Go.

Пример: расширение int

package main

import "fmt"

// MyInt - наш собственный тип на основе int
type MyInt int

// IsEven - метод, который мы добавляем к MyInt
func (mi MyInt) IsEven() bool {
    return mi%2 == 0
}

// Double - еще один полезный метод
func (mi MyInt) Double() MyInt {
    return mi * 2
}

func main() {
    x := MyInt(4)
    y := MyInt(7)

    fmt.Printf("%d is even: %t\n", x, x.IsEven()) // 4 is even: true
    fmt.Printf("%d is even: %t\n", y, y.IsEven()) // 7 is even: false

    doubled := x.Double()
    fmt.Printf("Double of %d is %d\n", x, doubled) // Double of 4 is 8
}

Пример: расширение string

package main

import (
    "fmt"
    "strings"
)

// MyString - наш тип на основе string
type MyString string

// Capitalize - метод, который возвращает строку с заглавной первой буквой
func (ms MyString) Capitalize() MyString {
    if len(ms) == 0 {
        return ms
    }
    // Преобразуем в руны для корректной работы с Unicode
    runes := []rune(ms)
    if runes[0] >= 'a' && runes[0] <= 'z' {
        runes[0] -= 32 // 'a' - 'A' = 32
    }
    return MyString(runes)
}

// Contains - проверка, содержит ли строка подстроку
func (ms MyString) Contains(substr string) bool {
    return strings.Contains(string(ms), substr)
}

func main() {
    s := MyString("hello world")
    fmt.Println(s.Capitalize()) // Hello world
    fmt.Println(s.Contains("world")) // true
}

Важные моменты и ограничения

• Приведение типов: Чтобы использовать методы, вам нужно явно преобразовать значение в ваш тип: x := MyInt(42). Обратное преобразование тоже явное: int(x).
• Наследование отсутствует: MyInt не наследует методы от int. У int вообще нет методов. Но вы можете использовать все операции (сложение, вычитание и т.д.), так как базовый тип — числовой.
• Совместимость: MyInt и int — это разные типы. Вы не сможете передать MyInt в функцию, ожидающую int, без явного преобразования.
• Именование: В реальных проектах давайте осмысленные имена: Counter, Price, UserID вместо MyInt.

Почему Go не поддерживает extension methods как в C#?

Go стремится к простоте и явности. Extension methods могут привести к "магическому" поведению, когда метод вызывается на типе, но определен где-то в другом пакете. В Go вы всегда видите, какие методы принадлежат типу — они объявлены в том же пакете, что и тип. Это делает код предсказуемым и упрощает его понимание.

Используйте описанный выше подход — создание нового типа. Это стандартная практика в Go, которая делает ваш код типобезопасным, читаемым и идиоматичным.

package main

import "fmt"

// isEven - обычная функция, принимающая int
func isEven(i int) bool {
    return i%2 == 0
}

// capitalize - функция для работы со строками
func capitalize(s string) string {
    if len(s) == 0 {
        return s
    }
    runes := []rune(s)
    if runes[0] >= 'a' && runes[0] <= 'z' {
        runes[0] -= 32
    }
    return string(runes)
}

func main() {
    x := 4
    fmt.Println(isEven(x)) // true

    s := "hello"
    fmt.Println(capitalize(s)) // Hello
}