Teil 3 - Einfache Strukturen

Was wäre ein Programm allerdings ohne einige grundlegende Strukturen? Zumindest einfache Vergleiche sollte eine Sprache bieten um auch Logik zu bieten, sollte man das schon aus anderen Sprachen kennen, so gibt es nur kleinere Unterschiede zu beachten. Doch nun zu den Strukturen.

If-Clause

Der wohl bekannteste Part in jeder Programmiersprache ist das if-then-else Konzept. Alles in einem Computer baut auf einfach Fallunterscheidungen auf. In Go ist if ziemlich einfach und auch wie immer sparsamer als in anderen Sprachen:

if x {
    return true
} else {
    return false
}

Eine sehr praktische Besonderheit ist allerdings die Möglichkeit schon in der If-Abfrage auch Aktionen auszuführen. So kann zum Beispiel der zu prüfende Wert zuerst von einer anderen Funktion abgerufen werden. Wichtig ist auch, dass alles was in diesem Teil der Abfrage definiert wird, auch nur im Scope der If-Abfrage verfügbar ist.

Scopes sind die "Reichweiten" von Variablen oder Funktionen. Wenn eine Variable im globalen Scope verfügbar ist, so kann von überall darauf zugegriffen werden. Für Variablen die in einzelnen Funktionen definiert werden, gilt deren Scope und sie sind nur Teil dieses Funktionsblocks.

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    }
    return lim
}

Hier kann man gut erkennen, dass v erst in der If-Abfrage definiert und sofort danach (nach dem ; ) benutzt wird. Zu beachten ist auch, die Verwendung des Semikolons, welches sonst in Go eher unpräsent ist.

For-Loops

Ein weiterer sehr wichtiger Teil von Programmen sind Schleifen. Es ist sehr oft nötig etwas immer wieder zu tun ohne das Programm neuzustarten, daher ist selbstverständlich auch das in Go gegeben.

For in Go ist genau so einfach wie vielfältig, doch der grundsätzliche Aufbau ist folgender:

sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

Auch das dürfte aus anderen Sprachen schon bekannt sein, der erste Teil definiert die Variable, der zweite vergleicht sie und der letzte ist für ihre Veränderung zuständig.

Ungewöhnlicher ist dann schon diese Variante:

sum := 1
for ; sum < 1000; {
    sum += sum
}

Wie man sieht, sind sowohl der definierende als auch der iterierende Teil der Schleife optional. Eigentlich kann sogar das ; entfernt werden:

sum := 1
for sum < 1000; {
    sum += sum
}

Damit haben wir das aus anderen Sprachen bekannte while auch in Go zu unserer Verfügung, nur eben als einfaches for. Wer nun noch eine unendliche Schleife braucht, kann das Ganze noch auf

for {
}

reduzieren.

Switch-Case

Switch ist wie in anderen Sprachen eine etwas andere Fallunterscheidung. Hier werden die Blöcke (cases) in ihrer Reihenfolge bei zutreffender Evaluation des cases ausgeführt:

func main() {
    i := 1
    switch i {
    case 0:
        fmt.Println("0 Call")
    case f():
        fmt.Println("f() Call")
    }
}

func f() int {
    fmt.Println("running f()")
    return 1
}

Hierbei wird aber nur der erste zutreffende case auch ausgeführt. Wenn i also 0 ist, wird die Funktion f() nie aufgerufen. Auch die Tatsache, dass ein case Funktionen aufrufen kann und deren Ergebnis dann als seinen Wert evaluiert, kann durchaus praktisch sein.

Defer

Abschließend bei den Strukturen noch etwas, das eigentlich mehr zu den Funktionen selbst passt: defer

Dieses Feature ist wohl eines der praktischsten in Go, denn es hilft menschliche Fehler zu vermeiden und macht dazu noch die Struktur von Funktionen ordentlicher.

func main() {
    defer fmt.Println("world")

    fmt.Println("hello")
}

defer sorgt dafür, dass die dazugehörige Funktion sicher mit dem Ende der umschließenden Funktion aufgerufen wird.
Das bedeutet, egal wie die Funktion zum Ende kommt (diverse return's, etc), die defer's werden aufgerufen. Ein gängiges Beispiel ist das schließen von Files, da dies immer sichergestellt sein sollte.

logFile, err := os.Create("file.log")
defer logFile.Close()
if err != nil {
    panic(err)
}

Bei mehreren defers in einer Funktion, werden diese in der first-in-last-out Reihenfolge ausgeführt (also das erste zuletzt).