21 Nützliche Pakete und Funktionen der Standardbibliothek

Die Standardbibliothek von Go ist sehr umfangreich und deckt viele Bereiche ab, darunter Dateiverarbeitung, Netzwerkkommunikation, Kryptographie, Textverarbeitung und mehr. Hier sind einige der nützlichsten Pakete und ihre Funktionen.

21.1 Paket fmt

Das Paket fmt wird häufig zur Formatierung und Ausgabe von Text verwendet. Es bietet Funktionen wie Println, Printf und Sprintf.

21.1.1 Beispiel 1:

package main

import "fmt"

func main() {
    name := "GoLang"
    version := 1.18
    fmt.Printf("Welcome to %s version %.2f\n", name, version)

    message := fmt.Sprintf("This is %s version %.2f", name, version)
    fmt.Println(message)
}

21.2 Paket strings

Das Paket strings bietet viele nützliche Funktionen zur Verarbeitung von Zeichenketten, wie das Zerlegen, Verbinden, Suchen und Ersetzen von Zeichenketten.

21.2.1 Beispiel 2:

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello, GoLang"
    fmt.Println(strings.ToUpper(str))
    fmt.Println(strings.Split(str, ","))
    fmt.Println(strings.Contains(str, "Go"))
}

21.3 Paket time

Das Paket time bietet Funktionen zum Arbeiten mit Datum und Uhrzeit, zum Messen von Zeitdauern und zur Steuerung von Abläufen mit Timern und Tickern.

21.3.1 Beispiel 3:

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println("Current time:", now)

    formatted := now.Format("2006-01-02 15:04:05")
    fmt.Println("Formatted time:", formatted)

    duration := time.Since(now.Add(-10 * time.Minute))
    fmt.Println("Duration:", duration)
}

21.4 Paket math

Das Paket math bietet grundlegende mathematische Funktionen und Konstanten.

21.4.1 Beispiel 4:

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println("Pi:", math.Pi)
    fmt.Println("Square root of 16:", math.Sqrt(16))
    fmt.Println("Power of 2^3:", math.Pow(2, 3))
}

21.5 Paket sort

Das Paket sort bietet Funktionen zum Sortieren von Slices und benutzerdefinierten Datentypen.

21.5.1 Beispiel 5:

package main

import (
    "fmt"
    "sort"
)

func main() {
    nums := []int{3, 1, 4, 1, 5, 9, 2, 6, 5}
    sort.Ints(nums)
    fmt.Println("Sorted numbers:", nums)

    words := []string{"Go", "Python", "Java", "C++"}
    sort.Strings(words)
    fmt.Println("Sorted words:", words)
}

21.6 Paket io und os

Die Pakete io und os bieten Funktionen zum Arbeiten mit Dateien, Verzeichnissen und allgemeinen Ein-/Ausgabeoperationen.

21.6.1 Beispiel 6:

package main

import (
    "fmt"
    "io/ioutil"
    "os"
)

func main() {
    content := []byte("Hello, GoLang!")
    err := ioutil.WriteFile("example.txt", content, 0644)
    if err != nil {
        fmt.Println("Error writing file:", err)
        return
    }

    data, err := ioutil.ReadFile("example.txt")
    if err != nil {
        fmt.Println("Error reading file:", err)
        return
    }
    fmt.Println("File content:", string(data))

    err = os.Remove("example.txt")
    if err != nil {
        fmt.Println("Error deleting file:", err)
        return
    }
    fmt.Println("File deleted")
}

21.7 Paket encoding/json

Das Paket encoding/json bietet Funktionen zum Kodieren und Dekodieren von JSON-Daten.

21.7.1 Beispiel 7:

package main

import (
    "encoding/json"
    "fmt"
)

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

func main() {
    p := Person{Name: "Alice", Age: 30}
    jsonData, err := json.Marshal(p)
    if err != nil {
        fmt.Println("Error marshaling JSON:", err)
        return
    }
    fmt.Println("JSON data:", string(jsonData))

    var p2 Person
    err = json.Unmarshal(jsonData, &p2)
    if err != nil {
        fmt.Println("Error unmarshaling JSON:", err)
        return
    }
    fmt.Println("Unmarshaled data:", p2)
}

21.8 Paket net/http

Das Paket net/http bietet Funktionen zur Erstellung von HTTP-Servern und -Clients.

21.8.1 Beispiel 8:

21.8.1.1 HTTP-Server

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, Go HTTP Server!")
}

func main() {
    http.HandleFunc("/hello", helloHandler)
    fmt.Println("Server started at :8080")
    http.ListenAndServe(":8080", nil)
}

21.8.1.2 HTTP-Client

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    resp, err := http.Get("http://example.com")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }

    fmt.Println("Response Body:", string(body))
}