Go-Struktur

Struktur ist ein benutzerdefinierter Typ, der Felder gruppieren kann. Strukturen werden verwendet, um komplexe Datentypen zu erstellen.

Deklaration

Strukturen werden mit dem Schlüsselwort struct deklariert.

type Person struct {
   Name string
   Age  int
}

Initialisierung

Strukturen können auf verschiedene Arten initialisiert werden.

// Reihenfolge der Felder
p1 := Person{"Alice", 25}

// Feldnamen
p2 := Person{Name: "Alice", Age: 25}

// Teilweise Felder
p3 := Person{Name: "Alice"}

// Leere Struktur
p4 := Person{}

Feldzugriff

p := Person{Name: "Alice", Age: 25}
fmt.Println(p.Name) // Alice
fmt.Println(p.Age)  // 25

p.Age = 26
fmt.Println(p.Age)  // 26

Zeiger auf Struktur

p := Person{Name: "Alice", Age: 25}
pp := &p
fmt.Println(pp.Name) // Alice
fmt.Println((*pp).Age) // 25

Go erlaubt den direkten Zugriff auf Felder über Zeiger.

p := Person{Name: "Alice", Age: 25}
pp := &p
fmt.Println(pp.Name) // Alice
pp.Age = 26

Anonyme Strukturen

Strukturen können ohne Typdeklaration verwendet werden.

p := struct {
   Name string
   Age  int
}{
   Name: "Alice",
   Age:  25,
}

Embedding

Strukturen können andere Strukturen einbetten.

type Animal struct {
   Name string
}

type Dog struct {
   Animal
   Breed string
}

func main() {
   d := Dog{
      Animal: Animal{Name: "Bello"},
      Breed:  "Husky",
   }
   fmt.Println(d.Name)  // Bello
   fmt.Println(d.Breed) // Husky
}

Feld-Tags

Felder können mit Tags versehen werden, die von Reflexion verwendet werden.

type Person struct {
   Name string `json:"name"`
   Age  int    `json:"age"`
}

Vergleichbarkeit

Strukturen sind vergleichbar, wenn alle Felder vergleichbar sind.

type Person struct {
   Name string
   Age  int
}

p1 := Person{Name: "Alice", Age: 25}
p2 := Person{Name: "Alice", Age: 25}
fmt.Println(p1 == p2) // true

nil Struktur

Strukturen können nicht nil sein, aber Zeiger auf Strukturen können nil sein.

var p *Person
fmt.Println(p == nil) // true

Methoden auf Strukturen

Strukturen können Methoden haben.

type Person struct {
   Name string
   Age  int
}

func (p Person) SayHello() {
   fmt.Printf("Hallo, mein Name ist %s\n", p.Name)
}

func (p *Person) Birthday() {
   p.Age++
}

func main() {
   p := Person{Name: "Alice", Age: 25}
   p.SayHello()   // Hallo, mein Name ist Alice
   p.Birthday()   // p.Age wird 26
}

Struktur-Initialisierungsfunktion

Es ist üblich, eine Funktion zur Initialisierung von Strukturen zu erstellen.

type Person struct {
   Name string
   Age  int
}

func NewPerson(name string, age int) *Person {
   return &Person{Name: name, Age: age}
}

func main() {
   p := NewPerson("Alice", 25)
   fmt.Println(p.Name) // Alice
}

Unexportierte Felder

Felder, die mit einem Kleinbuchstaben beginnen, sind nicht exportiert.

package main

type Person struct {
   name string // nicht exportiert
   Age  int    // exportiert
}

Struktur-Größe

Die Größe einer Struktur kann mit unsafe.Sizeof ermittelt werden.

import "unsafe"

type Person struct {
   Name string
   Age  int
}

func main() {
   var p Person
   fmt.Println(unsafe.Sizeof(p)) // 16 auf 64-Bit-System
}

Struktur-Padding

Strukturen können Padding haben, um die Speicherausrichtung zu optimieren.

import "unsafe"

type A struct {
   a byte
   b int32
   c byte
}

type B struct {
   a byte
   c byte
   b int32
}

func main() {
   fmt.Println(unsafe.Sizeof(A{})) // 12
   fmt.Println(unsafe.Sizeof(B{})) // 8
}

Struktur und JSON

Strukturen können einfach in JSON konvertiert werden.

import "encoding/json"

type Person struct {
   Name string `json:"name"`
   Age  int    `json:"age"`
}

func main() {
   p := Person{Name: "Alice", Age: 25}
   data, _ := json.Marshal(p)
   fmt.Println(string(data)) // {"name":"Alice","age":25}
}