Перейти на PRO

Что такое структура (`struct`) в Go и каковы её ключевые особенности?

Тип вопроса: Golang Вероятность: 10% Категория: Golang Разработчик

Ответ

Структура (struct) в Go — это композитный тип данных, который объединяет в себе именованные поля с различными типами. Она используется для группировки связанных данных в единую сущность.

Объявляется с помощью ключевых слов type и struct:

type Employee struct {
    ID        int
    FirstName string
    LastName  string
    IsActive  bool
}

Ключевые особенности структур в Go:

  1. Передача по значению (Value Type):

    • По умолчанию структуры передаются в функции по значению, то есть создаётся полная копия объекта. Изменения внутри функции не влияют на исходную структуру.

  2. Передача по указателю:

    • Чтобы избежать копирования и иметь возможность изменять исходный объект, структуры передают по указателю (*Employee). Это более эффективно для больших структур.

  3. Встраивание (Embedding):

    • Go поддерживает встраивание одной структуры в другую (аналог композиции, часто сравнивают с наследованием). Поля и методы встроенной структуры "поднимаются" на уровень внешней. 
      
type Person struct {
Name string
Age  int
}

    type Employee struct { Person // Встроенная структура Salary int }

    // Использование: // emp := Employee{} // emp.Name = "John" // Доступ к полю встроенной структуры

  4. Методы:

    • Для структур можно определять методы — функции с "получателем" (receiver), который связывает функцию с конкретным типом. 
      func (p *Person) Greet() string {
return "Hello, my name is " + p.Name
}

Ответ 18+ 🔞

А, структуры в Go, да? Ну это ж, блядь, как такая коробочка с ячейками, куда можно накидать всякой разной хуйни под одной крышкой. Типа, вот у тебя есть сотрудник — у него и имя есть, и фамилия, и зарплата, и ещё какая-нибудь ерунда вроде активен он или нет. Так вот, вместо того чтобы таскать эту кучу переменных по отдельности, ты их в одну пачку собираешь — это и есть структура, ёпта.

Объявляется это дело просто, как два пальца:

type Employee struct {
    ID        int
    FirstName string
    LastName  string
    IsActive  bool
}

Вот, смотри, создал тип Employee — и теперь у тебя есть своя собственная сущность, как лего-кирпичик. Красота, блядь.

А теперь про важные штуки, которые надо знать, чтобы не облажаться:

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

  2. Указатели — чтобы не копировать тонны данных. Поэтому умные дядьки передают указатель (*Employee). Передал адрес в памяти — и функция работает напрямую с оригиналом. И быстрее, и можно менять. Просто перед переменной амперсанд (&) поставь, когда вызываешь, и всё.

  3. Встраивание — композиция вместо наследования (которого тут нет, блядь!). Это одна из самых мощных фишек, ядрёна вошь! Можно одну структуру встроить в другую. Поля встроенной структуры становятся как бы своими. Не нужно это наследование с его проблемами — тут чистая композиция, всё прозрачно.

    type Person struct {
    Name string
    Age  int
}

type Employee struct {
    Person // Просто встроили Person. Никакого extends, блядь!
    Salary int
}

// Использование:
emp := Employee{}
emp.Name = "John" // Смотри-ка! Поле Name как будто сразу в Employee!

    Вот так, в рот меня чих-пых! Элегантно и без лишней ебли.

  4. Методы — привязываем поведение к данным. Ну а куда ж без методов? Это функции, которые прицеплены к конкретному типу. Получатель (receiver) указывается перед именем функции. Можешь привязать как к значению (тогда будет работать с копией), так и к указателю (будет работать с оригиналом и сможет его менять).

    func (p *Person) Greet() string {
    return "Hello, my name is " + p.Name
}

    Теперь у любой переменной типа Person (или у Employee, потому что Person в неё встроена!) есть метод .Greet(). Вызываешь — и он тебе строку отдаёт. Удобно, сука!

Короче, структуры в Go — это фундамент. На них всё строится. Понял принцип — половина языка уже в кармане. Главное — не путаться с указателями и помнить про встраивание, это ж пиздец как полезно.

© ХакСобесов, 2026
support@hacksobesov.com