Pakete, Module und Standardbibliothek

go mod init beispiel.de/rechner      # legt go.mod an

rechner/
├─ go.mod                     module beispiel.de/rechner
├─ main.go                    package main
└─ mathe/
   ├─ mathe.go                package mathe
   └─ mathe_test.go

// mathe/mathe.go
package mathe

func Addiere(a, b int) int { return a + b }     // Großbuchstabe: exportiert
func geheim() int          { return 42 }        // klein: nur im Paket

// main.go
package main

import (
    "fmt"
    "beispiel.de/rechner/mathe"
)

func main() {
    fmt.Println(mathe.Addiere(2, 3))
}

package main

import (
    "bufio"
    "fmt"
    "os"
    "path/filepath"
    "strings"
)

func main() {
    ordner, _ := os.MkdirTemp("", "kurs")
    defer os.RemoveAll(ordner)
    pfad := filepath.Join(ordner, "notiz.txt")

    if err := os.WriteFile(pfad, []byte("Zeile 1\nZeile 2\n"), 0o644); err != nil {
        fmt.Println(err)
        return
    }
    f, err := os.OpenFile(pfad, os.O_APPEND|os.O_WRONLY, 0o644)
    if err == nil {
        fmt.Fprintln(f, "Zeile 3")
        f.Close()
    }

    daten, _ := os.ReadFile(pfad)
    fmt.Println(strings.Count(string(daten), "\n"), "Zeilen")

    datei, _ := os.Open(pfad)
    defer datei.Close()
    scanner := bufio.NewScanner(datei) // zeilenweise
    for scanner.Scan() {
        fmt.Println(">", scanner.Text())
    }

    _, err = os.ReadFile(filepath.Join(ordner, "gibt-es-nicht"))
    fmt.Println(os.IsNotExist(err), err != nil)
}

package main

import (
    "encoding/json"
    "fmt"
)

type Nutzer struct {
    Name   string   `json:"name"`
    Alter  int      `json:"alter"`
    Hobbys []string `json:"hobbys,omitempty"`
    intern string   // klein: wird nicht serialisiert
}

func main() {
    mia := Nutzer{Name: "Mia", Alter: 17, Hobbys: []string{"Lesen", "Rad"}}
    daten, _ := json.Marshal(mia)
    fmt.Println(string(daten))
    schoen, _ := json.MarshalIndent(map[string]any{"ok": true, "zahl": 42}, "", "  ")
    fmt.Println(string(schoen))

    var tom Nutzer
    if err := json.Unmarshal([]byte(`{"name":"Tom","alter":19}`), &tom); err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%+v\n", tom)

    var beliebig map[string]any
    json.Unmarshal([]byte(`{"a":1,"b":[true,"x"]}`), &beliebig)
    fmt.Println(beliebig["a"], beliebig["b"])

    err := json.Unmarshal([]byte(`{kaputt`), &tom)
    fmt.Println(err != nil)
}

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2025, time.March, 8, 14, 30, 0, 0, time.UTC)
    fmt.Println(t.Format("02.01.2006 15:04"), t.Weekday(), t.YearDay())
    // Go formatiert mit dem Beispieldatum "Mon Jan 2 15:04:05 2006"
    fmt.Println(t.Add(36*time.Hour).Format(time.RFC3339), t.AddDate(0, 1, 0).Format("2006-01-02"))

    ende := time.Date(2025, 12, 24, 0, 0, 0, 0, time.UTC)
    fmt.Println(int(ende.Sub(t).Hours()/24), "Tage")

    p, err := time.Parse("02.01.2006", "24.12.2025")
    fmt.Println(p.Format("2006-01-02"), err)
    d, _ := time.ParseDuration("1h30m")
    fmt.Println(d, d.Minutes())

    start := time.Now()
    time.Sleep(20 * time.Millisecond)
    fmt.Println(time.Since(start) >= 20*time.Millisecond)
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hallo vom Server!")
    })
    mux.HandleFunc("GET /nutzer/{id}", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(map[string]string{"id": r.PathValue("id")})
    })
    log.Println("läuft auf http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

resp, err := http.Get("https://example.org")
if err != nil { return err }
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)