4 Syntax, Datentypen, Kontrollstrukturen

4.1 Ein einfaches “Hello, World”-Programm

Ein Go-Programm besteht aus Paketen, und jedes Programm startet im Paket main. Ein einfaches Go-Programm sieht zum Beispiel so aus:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go")
}

4.1.1 Schritte zur Ausführung:

  1. Erstellen Sie einen neuen Ordner für das Projekt: bash mkdir hello cd hello
  2. Erstellen Sie eine neue Datei mit dem Namen main.go und fügen Sie den obigen Code ein.
  3. Führen Sie das Programm aus: bash go run main.go Sie sollten die Ausgabe “Hello, Go” sehen.

4.2 Variablen und Datentypen

4.2.1 Deklaration und Initialisierung

Variablen werden in Go mit dem Schlüsselwort var deklariert. Alternativ können Sie die Kurzschreibweise := verwenden.

var name string
name = "GoLang"

name := "GoLang"

4.2.2 Primitive Typen

var age int = 30
var temperature float64 = 36.6
var isProgrammingFun bool = true
var language string = "Go"

4.2.3 Komplexe Typen

var arr [3]int = [3]int{1, 2, 3}
var slice []int = []int{1, 2, 3, 4, 5}
var m map[string]int = map[string]int{"one": 1, "two": 2}
type Person struct {
    Name string
    Age  int
}
var p Person = Person{Name: "Alice", Age: 30}

4.3 Kontrollstrukturen

4.3.1 If-Else

if age > 18 {
    fmt.Println("Erwachsen")
} else {
    fmt.Println("Nicht erwachsen")
}

4.3.2 Switch-Case

switch day := "Montag"; day {
case "Montag":
    fmt.Println("Wochenbeginn")
case "Freitag":
    fmt.Println("Wochenende naht")
default:
    fmt.Println("Ein anderer Tag")
}

4.3.3 For-Schleifen

4.3.3.1 Traditionelle For-Schleife

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

4.3.3.2 Range-basierte For-Schleife

nums := []int{1, 2, 3, 4, 5}
for index, num := range nums {
    fmt.Println(index, num)
}

4.3.3.3 While-ähnliche For-Schleife

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

4.4 Funktionen

4.4.1 Funktionsdefinition und Aufruf

func add(a int, b int) int {
    return a + b
}

result := add(3, 4)
fmt.Println(result)

4.4.2 Mehrere Rückgabewerte

func divide(a int, b int) (int, int) {
    quotient := a / b
    remainder := a % b
    return quotient, remainder
}

q, r := divide(10, 3)
fmt.Println(q, r)

4.4.3 Anonyme Funktionen und Closures

increment := func(x int) int {
    return x + 1
}
fmt.Println(increment(5))

func makeIncrementer() func(int) int {
    return func(x int) int {
        return x + 1
    }
}

inc := makeIncrementer()
fmt.Println(inc(5))

4.5 Datenstrukturen

4.5.1 Arrays

Arrays haben eine feste Größe.

var arr [3]int = [3]int{1, 2, 3}
fmt.Println(arr) // Ausgabe: [1 2 3]

4.5.2 Slices

Slices sind dynamisch und können in der Größe variieren.

slice := []int{1, 2, 3, 4, 5}
fmt.Println(slice) // Ausgabe: [1 2 3 4 5]

4.5.2.1 Common Operations

Hinzufügen:

slice = append(slice, 6)
fmt.Println(slice) // Ausgabe: [1 2 3 4 5 6]

Entfernen:

slice = slice[1:] // Entfernt das erste Element
fmt.Println(slice) // Ausgabe: [2 3 4 5 6]

Kopieren:

slice2 := make([]int, len(slice))
copy(slice2, slice)
fmt.Println(slice2) // Ausgabe: [2 3 4 5 6]

4.5.3 Maps

Maps sind Schlüssel-Wert-Paare und sehr flexibel in der Verwendung.

var m map[string]int = map[string]int{"one": 1, "two": 2}
m["three"] = 3
fmt.Println(m) // Ausgabe: map[one:1 two:2 three:3]

4.5.3.1 Iteration über Maps

for key, value := range m {
    fmt.Println(key, value)
}

4.5.4 Structs

Structs sind benutzerdefinierte Datentypen, die eine Sammlung von Feldern enthalten.

type Person struct {
    Name string
    Age  int
}

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

4.5.4.1 Methoden an Structs

Methoden können an Structs definiert werden, um Verhalten zu implementieren.

func (p Person) Greet() string {
    return "Hello, " + p.Name
}

p := Person{Name: "Alice"}
fmt.Println(p.Greet()) // Ausgabe: Hello, Alice

4.5.4.2 Verschachtelte Structs

Structs können andere Structs als Felder enthalten.

type Address struct {
    City, State string
}

type Person struct {
    Name    string
    Age     int
    Address Address
}

p := Person{Name: "Alice", Age: 30, Address: Address{City: "New York", State: "NY"}}
fmt.Println(p) // Ausgabe: {Alice 30 {New York NY}}

4.6 Algorithmen

4.6.1 Sortieren

Go bietet das sort Paket zum Sortieren von Slices.

import "sort"

nums := []int{5, 3, 4, 1, 2}
sort.Ints(nums)
fmt.Println(nums) // Ausgabe: [1 2 3 4 5]

4.6.2 Suche

4.6.2.1 Lineare Suche

func linearSearch(nums []int, target int) int {
    for i, num := range nums {
        if num == target {
            return i
        }
    }
    return -1
}

index := linearSearch([]int{1, 2, 3, 4, 5}, 3)
fmt.Println(index) // Ausgabe: 2

4.6.2.2 Binäre Suche

func binarySearch(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        mid := left + (right-left)/2
        if nums[mid] == target {
            return mid
        } else if nums[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return -1
}

index := binarySearch([]int{1, 2, 3, 4, 5}, 3)
fmt.Println(index) // Ausgabe: 2

4.6.3 Rekursion

Rekursion ist eine Technik, bei der eine Funktion sich selbst aufruft, um ein Problem zu lösen.

func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}

fmt.Println(factorial(5)) // Ausgabe: 120

4.7 Arbeiten mit Paketen

4.7.1 Import und Nutzung von Standardbibliotheken

import (
    "fmt"
    "math"
)

fmt.Println(math.Sqrt(16))

4.7.2 Erstellen und Nutzen eigener Pakete

package mypackage

func Hello() string {
    return "Hello, World!"
}

4.7.3 Modulverwaltung

go mod init example.com/mymodule
go get some/package
package main

import "example.com/mymodule/mypackage"

func main() {
    fmt.Println(mypackage.Hello())
}