Давайте поговорим о методах, или иногда их еще называют приемниками функций.

Технически, Go не является объектно-ориентированным языком программирования. В нем нет классов, объектов и наследования.

Однако в Go есть типы. И вы можете определять методы на типах.

Метод — это не что иное, как функция со специальным аргументом-приемником. Давайте посмотрим, как можно объявлять методы.

func (variable T) Name(params) (returnTypes) {}

Аргумент-приемник имеет имя и тип. Он появляется между ключевым словом func и именем метода.

Например, определим структуру Car.

type Car struct {
    Name string
    Year int
}

Теперь определим метод IsLatest, который будет определять, был ли автомобиль произведен в течение последних 5 лет.

func (c Car) IsLatest() bool {
    return c.Year >= 2017
}

Как видите, мы можем получить доступ к экземпляру Car с помощью переменной-приемника c. Мне нравится думать об этом как о ключевом слове this из объектно-ориентированного мира.

Теперь мы должны иметь возможность вызывать этот метод после инициализации нашей структуры, точно так же, как мы делаем это с классами в других языках.

func main() {
    c := Car{"Tesla", 2021}

    fmt.Println("IsLatest", c.IsLatest())
}

Методы с приемниками указателей

Все примеры, которые мы рассматривали ранее, имели приемник значения.

С приемником значения метод работает с копией переданного ему значения. Поэтому любые изменения, сделанные с приемником внутри методов, не видны вызывающей стороне.

Например, давайте создадим еще один метод под названием UpdateName, который будет обновлять название Car.

func (c Car) UpdateName(name string) {
    c.Name = name
}

Теперь давайте запустим это.

func main() {
    c := Car{"Tesla", 2021}

    c.UpdateName("Toyota")
    fmt.Println("Car:", c)
}

$ go run main.go
Car: {Tesla 2021}

Похоже, что имя не было обновлено, поэтому теперь переключим наш приемник на стрелочный тип и попробуем снова.

func (c *Car) UpdateName(name string) {
    c.Name = name
}

$ go run main.go
Car: {Toyota 2021}

Как и ожидалось, методы с приемниками-указателями могут изменять значение, на которое указывает приемник. Такие изменения видны и вызывающему методу.

Свойства

Давайте также посмотрим на некоторые свойства методов!

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

(&c).UpdateName(...)

• Мы можем опустить переменную часть приемника, если мы ее не используем.

func (Car) UpdateName(...) {}

• Методы не ограничиваются структурами, их можно использовать и с неструктурными типами.

package main

import "fmt"

type MyInt int

func (i MyInt) isGreater(value int) bool {
    return i > MyInt(value)
}

func main() {
    i := MyInt(10)

    fmt.Println(i.isGreater(5))
}

Почему методы, а не функции?

Возникает вопрос, почему именно методы, а не функции?

Как всегда, на этот вопрос нет конкретного ответа, и ни в коем случае нельзя сказать, что одно лучше другого. Наоборот, их следует использовать соответствующим образом, когда возникает ситуация.

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

Поскольку метод привязан к определенному типу, мы можем использовать одни и те же имена методов для нескольких приемников.

Но вообще, это может сводиться к предпочтениям? Например, «вызовы методов гораздо легче читать и понимать, чем вызовы функций» или наоборот.

Эта статья является частью моего открытого курса по Go, доступного на Github.