Vad är structs i Go?

Question

Accepted Answer

En **struct** är en sammansatt typ som grupperar relaterade fält tillsammans — Go:s sätt att definiera anpassade datatyper och modellera enheter. Eftersom Go inte har klasser, är structs (plus metoder) det sätt du gör objektorienterad programmering på.

## Definiera och använd en struct

```go
type Person struct {
    Name string     // exported (capitalized) → accessible from other packages
    Age  int
    email string    // unexported (lowercase) → package-private
}

// creating instances
p1 := Person{Name: "Ann", Age: 30}        // named fields (preferred — clear, order-independent)
p2 := Person{"Bob", 25, "bob@x.com"}       // positional (fragile — order matters)
var p3 Person                              // zero value: {"", 0, ""}

p1.Name          // access fields with dot notation
p1.Age = 31      // mutate
```

## Fältsynlighet via kapitalisering

```text
Capitalized field/type/func name → EXPORTED (public, usable outside the package)
lowercase name → unexported (private to the package)
```

Go använder kapitalisering, inte nyckelord, för synlighet — en distinktiv konvention.

## Metoder på structs (Go:s OOP)

```go
// a method is a function with a RECEIVER (the struct it operates on)
func (p Person) Greet() string {           // value receiver
    return "Hi, I'm " + p.Name
}
func (p *Person) Birthday() {                // pointer receiver — can MODIFY the struct
    p.Age++
}

p1.Greet()       // "Hi, I'm Ann"
p1.Birthday()    // modifies p1 (Go auto-takes the address)
```

Metoder kopplar beteende till structs via en *mottagare*. Pekartagare (`*Person`) låter metoder ändra struct; värdesmottagare får en kopia.

## Structs är värdetyper

```go
p1 := Person{Name: "Ann"}
p2 := p1            // COPIES the entire struct (independent)
p2.Name = "Bob"
fmt.Println(p1.Name)   // "Ann" — unchanged (it was a copy)

// pass a pointer to share/modify
func update(p *Person) { p.Name = "X" }
```

Attribuering eller skickning av en struct **kopierar** den (värdessemantik) — för att dela eller ändra, använd en pekare.

## Struct-taggar (metadata)

```go
type User struct {
    Name  string `json:"name"`           // tags guide encoding/decoding
    Email string `json:"email,omitempty"`
}
```

Taggar kopplar metadata (använd av JSON, DB, valideringsbibliotek) läst via reflektion.

## Varför det spelar roll

Structs är det grundläggande sättet att modellera data och bygga anpassade typer i Go — och kombinerat med metoder är de hur Go gör objektorienterad programmering (det har ingen klasser).

Förståelse av struct-definition, **kapitaliseringsbaserad synlighetkonvention** (unik för Go), **värdessemantik** (tilldelning kopierar — så använd pekare för att dela/ändra, en vanlig fallgrop), metoder med värdes- kontra pekartagare, och struct-taggar (för JSON/DB-mappning) är grundläggande för nästan all Go-kod.

Structs förekommer överallt — domänmodeller, konfiguration, API-nyttolaster, datastrukturer — vilket gör dem till essentiell, daglig kunskap för att arbeta effektivt i Go.