Structs

var title1 = "The Go programming language"
var author1 = "John Doe"
var pages1 = 380

var title2 = "Clean Code"
var author2 = "Tom Brown"
var pages2 = 464

// Bei einem neuen Feld - Änderung der Signatur der Funktion
func PrintBook(title string, author string, pages int, isbn string, available bool) { /* ... */ }

// Aufruf
PrintBook(title1, author1, pages1, isbn1, available1)

type Book struct {
    Title string
    Author string
    Pages int
    ISBN string
    Available bool
}

book1 := Book{
    Title: "The Go programming language",
    Author: "John Doe",
    Pages: 380,
    ISBN: "987-65432101234",
    Available: true,
}

func PrintBook(b Book) {
    fmt.Printf("%s by %s\n", b.Title, b.Author)
}

type NameOfStruct struct {
    FieldName1 Type1
    FieldName2 Type2
    // ...
}

type Celsius struct {
    Value float64
}

type Fahrenheit struct {
    Value float64
}

var c Celsius
var f Fahrenheit

fmt.Println(c == f)

// Alias => MyInt und int sind austauschbar
type MyInt = int

// Neuer Typ => NewInt und int sind NICHT austauschbar
type NewInt int

package store

type Product struct {
    Name string // Exportiert
    Price float64 // Exportiert
    internalId string // Privat
}

package user

type Account struct {
    Name string
    balance int
}

// Kontrollierter Zugriff via Methoden
func (a *Account) Deposit(amount int) error {
    if amount <= 0 {
        return errors.New("amount must be positive")
    }

    // Zugriff erlaubt, da im selben Package
    a.balance += amount
    return nil
}

// Read-only Zugriff von außen
func (a *Account) Balance() int {
    return a.balance
}

type ComplexStruct struct {

    // Primitive Typen
    Name string
    Age int
    Active bool

    // Arrays und Slices
    Scores [5]int       // Array fixer Größe
    Tags []string       // Slice (dynamisch)

    // Maps
    Metadata map[string]any

    // Pointer
    Parent *ComplexStruct

    // Funktionen
    OnChange func(string) error

    // Andere Structs
    Address Address

    // Interface
    Logger io.Writer

    // Channels
    Events chan Event

}

type Server struct {
    Name string
    Port int
    OnRequest func(*Request) *Response  // Callback
    Middleware []HandlerFunc            // Stack von Handlers
    logger *log.Logger                  // Private Dependency
}

type Point struct {
    X, Y int
}

type Rectangle struct {
    Min, Max Point
}

// ⚠️ Schwer lesbar
type Person struct {
    FirstName, LastName, MiddleName, Title string
}

// ✅ Klarer
type Person struct {
    FirstName string
    LastName string
    MiddleWare string
    Title string
}

type Address struct {
    City string
    Street string
    ZipCode int
}

type Person struct {
    Name string
    Address Address // Ein Struct im Struct
}

// Zugriff
p := Person{
    Name: "John",
    Address: Address{
        City: "Berlin",
        Street: "Hauptstr. 1",
        ZipCode: 12345,
    },
}

type Person struct {
    Name string
    Contact struct {
        Email string
        Phone string
    }
}

type Node struct {
    Value int
    Next *Node // Zeiger auf den nächsten Knoten (rekursiv)
}

type LinkedList struct {
    Head *Node
}

func (l *LinkedList) Append(value int) {
    newNode := &Node{Value: value}
    if l.Head == nil {
        l.Head = newNode
        return
    }

    current := l.Head
    for current.Next != nil {
        current = current.Next
    }

    current.Next = newNode
}

type TreeNode struct {
    Value int
    Left *TreeNode
    Right *TreeNode
}

p := Person{
    Name: "John",
    Age: 30,
}

p := Person{"John": 30}

// Weg A => Adress-Operator
p := &Person{Name: "John"}

// Weg B => new() Funktion
p2 := new(Person)
p2.Name = "Bob"

func NewServer(port int) *Server {
    return &Server{
        Port: port,
        Status: "stopped",
        CreatedAt: time.Now(),
    }
}

func NewDatabase(connString string) (*Database, error) {
    if connString == "" {
        return nil, errors.New("connection string required")
    }

    db := &Database{
        connections: make(map[string]*Conn),
        maxConns: 100,
    }

    if err := db.connect(connString); err != nil {
        return nil, fmt.Errorf("failed to connect: %w", err)
    }

    return db, nil
}

type Server struct {
    Port int
    Timeout time.Duration
    MaxConns int
}

type Option func(*Server)

func WithTimeout(d time.Duration) Option {
    return func(s *Server) {
        s.Timeout = d
    }
}

func WithMaxConns(n int) Option {
    return func(s *Server) {
        s.MaxConns = n
    }
}

func NewServer(port int, opts ...Option) *Server {
    s := &Server{
        Port: port,
        Timeout: 30 * time.Second,
        MaxConns: 100,
    }

    for _, opt := range opts {
        opts(s)
    }

    return s
}

server := NewServer(
    8000,
    WithTimeout(60 * time.Second),
    WithMaxConns(200),
)

type Address struct {
    Street string
    City string
    ZipCode int
}

type Person struct {
    Name string
    Age int
    Address
}

var p Person
fmt.Println(p)

{ 0 {  0}}
-||--|||--
 12  345

var x int // x ist garantiert 0

type Metadata struct {
    FieldOne string
    FieldTwo int
}

type Stats struct {
    Count int // 0
    Average float64 // 0.0
    IsActive bool // false
    Name string // ""
    Scores []int // nil (nicht leerer Slice)
    Data map[string]int // nil (nicht leere Map)
    Metadata *Metadata // nil
}

var s Stats
fmt.Printf("%+v\n", s)
fmt.Println(s.Scores == nil)
fmt.Println(s.Data == nil)

var s1 []int            // nil slice
s2 := []int{}           // leerer Slice (nicht nil)
s3 := make([]int, 0)    // leerer Slice (nicht nil)

fmt.Println(s1 == nil) // true
fmt.Println(s2 == nil) // false
fmt.Println(s3 == nil) // false

// Das Verhalten ist aber ähnlich
fmt.Println(len(s1)) // 0
fmt.Println(len(s2)) // 0

var nilSlice []int
emptySlice := []int{}

nilSlice = append(nilSlice, 1)      // OK
emptySlice = append(emptySlice, 1)  // OK

package main

import "fmt"

type Config struct {
    Host string
    Port int
}

func (c Config) IsZero() bool {
    return c == Config{} // Vergleich mit Zero Value
}

func main() {
    var cfg Config
    if cfg.IsZero() {
        cfg = Config{Host: "localhost", Port: 8000}
        fmt.Println(cfg)
    }
}

package main

import (
    "fmt"
)

type Point struct {
    X, Y int
}

type Server struct {
    Tags []string
}

func main() {
    p1 := Point{1, 2}
    p2 := Point{1, 2}
    fmt.Println(p1 == p2)

    s1 := Server{Tags: []string{"web"}}
    s2 := Server{Tags: []string{"web"}}
    fmt.Println(s1 == s2)
}

package main

import "fmt"

type Point struct {
    X, Y int
}

func main() {

    // Primitive Typen
    var a, b int = 5, 5
    fmt.Printf("%d == %d = %t\n", a, b, (a == b))

    // Strings
    var s1, s2 string = "Hello", "Hello"
    fmt.Printf("%s == %s = %t\n", s1, s2, (s1 == s2))

    // Pointer (vergleichen die Adresse, nicht den Inhalt)
    p1 := &Point{1, 2}
    p2 := &Point{1, 2}

    // Vergleiche die Speicheradressen
    fmt.Printf("%p == %p = %t\n", p1, p2, (p1 == p2))

    // Vergleichen den Inhalt
    fmt.Printf("%v == %v = %t\n", *p1, *p2, (*p1 == *p2))

    // Arrays (element-weise Vergleich)
    arr1 := [3]int{1, 2, 3}
    arr2 := [3]int{1, 2, 3}
    fmt.Printf("%v == %v = %t\n", arr1, arr2, (arr1 == arr2))

    // Structs (alle Felder müssen vergleichbar sein)
    type Simple struct { A int; B string }
    s1 := Simple{1, "a"}
    s2 := Simple{1, "a"}
    fmt.Printf("%v == %v = %t\n", s1, s2, (s1 == s2))

}

// Slices
slice1 := []int{1, 2, 3}
slice2 := []int{1, 2, 3}
fmt.Println(slice1 == slice2) // ❌ Compile Error

// Maps
map1 := map[string]int{"a": 1}
map2 := map[string]int{"a": 1}
fmt.Println(map1 == map2) // ❌ Compile Error

// Functions
func1 := func() {}
func2 := func() {}
fmt.Println(func1 == func2) // ❌ Compile Error

slice1 := []int{1, 2, 3}
slice2 := slice1[:] // Zeigt auf dasselbe Array

// Was sollte == bedeuten?
// Gleiche Referenz oder gleicher Inhalt?

package main

import (
    "fmt"
    "reflect"
)

type Server struct {
    Tags []string
}

func main() {
    // Gleiche Inhalte
    s1 := Server{Tags: []string{"web", "api"}}
    s2 := Server{Tags: []string{"web", "api"}}
    fmt.Println(reflect.DeepEqual(s1, s2))

    // Unterschiedliche Inhalte
    s11 := Server{Tags: []string{"web", "api"}}
    s22 := Server{Tags: []string{"web", "desktop"}}
    fmt.Println(reflect.DeepEqual(s11, s22))
}

package main

import "fmt"

type User struct {
    Id int
    Name string
    Tags []string
    Metadata map[string]string
}

func (u User) Equal(other User) bool {

    // Id und Name vergleichen
    if u.Id != other.Id || u.Name != other.Name {
        return false
    }

    // Slices - Länge und Inhalt
    if len(u.Tags) != len(other.Tags) {
        return false
    }
    for i := range u.Tags {
        if u.Tags[i] != other.Tags[i] {
            return false
        }
    }

    // Maps - Länge und Inhalt
    if len(u.Metadata) != len(other.Metadata) {
        return false
    }
    for k, v := range u.Metadata {
        if otherV, ok := other.Metadata[k]; !ok || v != otherV {
            return false
        }
    }

    return true

}

func main() {

    // Gleich Benutzer
    u1 := User{
        Id: 1,
        Name: "John",
        Tags: []string{"one", "eins"},
        Metadata: map[string]string{
            "one": "100",
            "two": "200",
        },
    }
    u2 := User{
        Id: 1,
        Name: "John",
        Tags: []string{"one", "eins"},
        Metadata: map[string]string{
            "one": "100",
            "two": "200",
        },
    }

    fmt.Println(u1.Equal(u2))

    // Unterschiedliche Benutzer
    u3 := User{
        Id: 3,
        Name: "Alice",
        Tags: []string{"one", "eins"},
        Metadata: map[string]string{
            "three": "300",
            "four": "400",
        },
    }
    u4 := User{
        Id: 4,
        Name: "Tom",
        Tags: []string{"one", "eins"},
        Metadata: map[string]string{
            "one": "100",
            "two": "200",
        },
    }
    fmt.Println(u3.Equal(u4))

}

package main

import (
    "fmt"

    "github.com/google/go-cmp/cmp"
    "github.com/google/go-cmp/cmp/cmpopts"
)

type Server struct {
    Tags []string
    CreatedAt string
}

func main() {
    
    s1 := Server{Tags: []string{"web"}}
    s2 := Server{Tags: []string{"web"}}

    if cmp.Equal(s1, s2) {
        fmt.Println("Equal")
    }

    // Mit Optionen - Felder ignorieren
    if cmp.Equal(s1, s2, cmpopts.IgnoreFields(Server{}, "CreatedAt")) {
        fmt.Println("Equal without CreatedAt")
    }

}

package main

import "fmt"

type Person struct { Name string }

func main() {

    p1 := &Person{Name: "Alice"}
    p2 := &Person{Name: "Alice"}
    p3 := p1 // Referenz

    // Pointer-Vergleich (Adresse)
    fmt.Printf("p1 == p2 = %t\n", (p1 == p2))
    fmt.Printf("p1 == p3 = %t\n", (p1 == p3))

    // Wert-Vergleich
    fmt.Printf("*p1 == *p2 = %t\n", (*p1 == *p2))

}

class Counter {
    private int count = 0;

    public void add(int n) {
        count += n;
    }

    public void addAll(List<Integer> numbers) {
        for (int n : numbers) {
            add(n); // Nutzt add() intern
        }
    }
}

class LoggingCounter extends Counter {
    @Override
    public void add(int n) {
        System.out.println("Adding: " + n);
        super.add(n);
    }

    // Bug: addAll() ruft add() auf, was zu doppeltem Logging führt
}

type User struct {
    Name string
    Email string
}

type Admin struct {
    User
    Level int
}

// Das schreiben wir
type Admin struct {
    User
    Level int
}

// Der Compiler sieht intern
type Admin struct {
    User User // Automatisch generierter Feldname (Typ-Name)
    Level int
}

package main

import "fmt"

type User struct {
    Name string
    Email string
}

type Admin struct {
    User
    Level int
}

func main() {

    admin := Admin{
        User: User{
            Name: "John Doe",
            Email: "doe@mail.com",
        },
        Level: 1,
    }

    // Zugriff direkt auf Admin,
    // obwohl Name eigentlich in User liegt
    fmt.Println(admin.Name)
    fmt.Println(admin.Email)

    // Der lange Weg funktioniert auch
    fmt.Println(admin.User.Name)

}

package main

import "fmt"

type Inner struct {
    Public string
    private string
}

type Outer struct {
    Inner
}

func main() {
    o := Outer{Inner: Inner{Public: "A", private: "b"}}
    fmt.Println(o.Public)
    fmt.Println(o.private)
    fmt.Println(o.Inner.private)
}

package lib

type Inner struct {
    Public string
    private string
}

package main

import (
    "fmt"

    "mypackagename/lib"
)

type Outer struct {
    lib.Inner
}

func main() {
    o := Outer{Inner: lib.Inner{Public: "A", private: "b"}}
    // cannot refer to unexported field private in struct literal of type lib.Inner 
}

package main

import "fmt"

type User struct {
    Name string
}

func (u User) Greet() {
    fmt.Println("Hi, I am", u.Name)
}

type Admin struct {
    User
    Level int
}

func main() {
    admin := Admin{
        User: User{Name: "John"},
        Level: 1,
    }

    // Methode von User wird promoted
    admin.Greet()

    // Äquivalent zu
    admin.User.Greet()
}

package main

import (
    "fmt"
)

// Interface
type Writer interface {
    Write([]byte) (int, error)
}

// Einfache "Writer" Implementierung
type SimpleWriter struct{}

// Interface Implementierung für SimpleWriter
func (s SimpleWriter) Write(data []byte) (int, error) {
    fmt.Print(string(data))
    return len(data), nil
}

// Normaler Logger
type Logger struct {
    output Writer // "output" ist Name des Feldes
}

// Typ-Methode für Logger
func (l Logger) Log(msg string) {
    l.output.Write([]byte(msg))
}

// Besserer Logger
type BetterLogger struct {
    Writer // KEIN Feldname
}

// Typ-Methode für BetterLogger
func (l BetterLogger) Log(msg string) {
    l.Write([]byte(msg))
}

func main() {

    w := SimpleWriter{}

    // Logger verwenden
    loggerSimple := Logger{output: w}
    loggerSimple.Log("Test 1\n")
    loggerSimple.output.Write([]byte("Direkt\n"))

    // BetterLogger verwenden
    loggerExtended := BetterLogger{Writer: w}
    loggerExtended.Log("Test 2\n")
    loggerExtended.Write([]byte("Direkt\n"))

}

type Writer interface {
    Write([]byte) (int, error)
}

type SimpleWriter struct{}

func (s SimpleWriter) Write(data []byte) (int, error) {
    fmt.Print(string(data))
    return len(data), nil
}

type Logger struct {
    output Writer // "output" ist der Feldname
}

Logger = {
    output: <hier_liegt_ein_Writer>
}

func (l Logger) Log(msg string) {
    l.output.Write([]byte(msg))
}

type BetterLogger struct {
    Writer // Kein Feld - nur der Typ steht da
}

BetterLogger = {
    Writer: <hier liegt ein Writer>
}

func (l BetterLogger) Log(msg string) {
    l.Write([]byte(msg))
}

l.Write(...) => l.Writer.Write(...) 

package main

import "fmt"

type A struct { ID int }
type B {
    A
    ID int // Shadowing
}

func main() {

    b := B{}
    b.ID = 10 // Setzt B.ID
    b.A.ID = 5 // Setzt A.ID

    fmt.Printf("b.ID => %d\n", b.ID)
    fmt.Printf("b.A.ID => %d\n", b.A.ID)

}

type User struct {
    ID int `json:"id"` // Tag: json:"id"
    Name string `json:"name,omitempty"` // Tag: json:"name,omitempty"
}

`key1:"value1" key2:"value2,option1,option2"`

type User struct {
    ID int `json:"id" db:"primaryKey" validate:"required"`
    FullName string `json:"fullName,omitempty" db:"name"`
    Email string `json:"email" db:"email" validate:"required,email"`
    Password string `json:"-" db:"passwordHash"`
    createdAt string // Kein Tag - wird von Reflection-basierten Libs oft ignoriert
}

type Article struct {
    ID int `json:"id"`
    Title string `json:"title"`
    AuthorID int `json:"authorId,omitempty"`
    Content string `json:"content"`
    IsPublished bool `json:"isPublished"`
    Password string `json:"-"`
    CreatedAt time.Time `json:"createdAt,omitempty"`
}

package main

import (
    "fmt"
    "encoding/json"
)

type Response struct {
    Id int `json:"id,string"`
    Status string `json:"status"`
    Message string `json:"message,omitempty"`
    Data []int `json:"data,omitempty"`
}

func main() {

    r1 := Response{
        Status: "ok",
        Message: "Success",
        Data: []int{1, 2, 3},
    }

    jsonData, err := json.Marshal(r1)
    if err != nil {
        fmt.Println("Fehler:", err)
        return
    }

    fmt.Println(string(jsonData))

    r2 := Response{Id: 1, Status: "ok"}
    jsonData2, err := json.Marshal(r2)
    if err != nil {
        fmt.Println("Fehler:", err)
        return
    }

    // Hier wird Message und Data weggelassen
    fmt.Println(string(jsonData2))

}

package main

import (
    "fmt"
    "encoding/json"
)

type Response struct {
    NilSlice []int `json:"nilSlice"`
    EmptySlice []int `json:"emptySlice"`
}

func main() {

    r := Response{
        NilSlice: nil,
        EmptySlice: []int{},
    }

    jsonData, err := json.Marshal(r)
    if err != nil {
        fmt.Println("Fehler:", err)
    }

    fmt.Println(string(jsonData))

}

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    ID int `json:"id" db:"userId"`
    Name string `json:"name,omitempty" validate:"required"`
}

func main() {

    u := User{ID: 1, Name: "John"}

    // Typ per Reflection holen
    t := reflect.TypeOf(u)
    fmt.Println(t)

    // Über alle Felder iterieren
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)

        fmt.Printf("Feld: %s\n", field.Name)
        fmt.Printf("\tTag (gesamt): %q\n", field.Tag)
        fmt.Printf("\tjson-Tag: %q\n", field.Tag.Get("json"))
        fmt.Printf("\tdb-Tag: %q\n", field.Tag.Get("db"))
        fmt.Printf("\tvalidate-Tag: %q\n", field.Tag.Get("validate"))
        fmt.Println()
    }

}

package main

import (
    "fmt"	
    "reflect"
)

type Product struct {
    ID int `json:"id" db:"productId"`
    Name string `json:"name" db:"productName"`
    Price float64 `currency:"EUR"`
}

func main() {

    p := Product{
        ID: 1,
        Name: "Laptop",
        Price: 920.00,
    }

    // Typ-Informationen holen
    t := reflect.TypeOf(p)

    // Durch alle Felder iterieren
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)

        // Tags auslesen
        dbTag := field.Tag.Get("db")
        jsonTag := field.Tag.Get("json")
        currencyTag := field.Tag.Get("currency")

        fmt.Printf("Feld: %s\n", field.Name)
        fmt.Printf("\tdb-Tag: %s\n", dbTag)
        fmt.Printf("\tjson-Tag: %s\n", jsonTag)
        fmt.Printf("\tcurrency-Tag: %s\n", currencyTag)
        fmt.Println("---")
    }

}

package main

import (
    "fmt"
    "reflect"
    "strconv"
    "strings"
)

type Registration struct {
    Username string `validate:"required,min=3,max=20"`
    Email    string `validate:"required,email"`
    Age      int    `validate:"min=18"`
    Website  string `validate:"url,optional"`
}

// Validierungsfunktion
func ValidateStruct(data any) error {
    v := reflect.ValueOf(data)
    t := reflect.TypeOf(data)

    for i := 0; i < v.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        tag := field.Tag.Get("validate")

        if tag == "" { continue }

        // Tags parsen (vereinfacht)
        rules := strings.Split(tag, ",")

        for _, rule := range rules {
            switch {
            case rule == "required":
                if isEmpty(value) {
                    return fmt.Errorf("%s ist erforderlich", field.Name)
                }

            case strings.HasPrefix(rule, "min="):
                minStr := strings.TrimPrefix(rule, "min=")
                min, err := strconv.Atoi(minStr)
                if err != nil {
                    return fmt.Errorf("ungültiger min-Wert für %s", field.Name)
                }

                switch value.Kind() {
                case reflect.String:
                    if len(value.String()) < min {
                        return fmt.Errorf("%s muss mindestens %d Zeichen lang sein", field.Name, min)
                    }

                case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                    if value.Int() < int64(min) {
                        return fmt.Errorf("%s muss mindestens %d sein", field.Name, min)
                    }
                }

            case rule == "email":
                if !isValidEmail(value.String()) {
                    return fmt.Errorf("%s ist keine gültige Email", field.Name)
                }

            case rule == "optional":
                // Optionales Feld - keine Validierung
                continue
            }
        }
    }

    return nil
}

func isEmpty(v reflect.Value) bool {
    // Vereinfachte Prüfung
    return v.Interface() == reflect.Zero(v.Type()).Interface()
}

func isValidEmail(s string) bool {
    return strings.Contains(s, "@") && strings.Contains(s, ".")
}

func main() {
    userRegistration := Registration{
        Username: "ab", // Zu kurz
        Email: "test@example.com",
        Age: 16, // Zu jung
    }

    err := ValidateStruct(userRegistration)
    if err != nil {
        fmt.Printf("Fehler: %v\n", err)
    }
}