Wir stellen vor: Go

Kapitel 4. Strukturen kontrollieren

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: [e-mail]

Jetzt, wo du weißt, wie du Variablen verwenden kannst, ist es an der Zeit, ein paar nützliche Programme zu schreiben. Als erstes wollen wir ein Programm schreiben, das von 1 bis 10 zählt, wobei jede Zahl in einer eigenen Zeile steht. Mit dem, was du bis jetzt gelernt hast, könntest du das so schreiben:

package main

import "fmt"

func main() {
    fmt.Println(1)
    fmt.Println(2)
    fmt.Println(3)
    fmt.Println(4)
    fmt.Println(5)
    fmt.Println(6)
    fmt.Println(7)
    fmt.Println(8)
    fmt.Println(9)
    fmt.Println(10)
}

Oder dies:

package main
import "fmt"

func main() {
  fmt.Println(`1
2
3
4
5
6
7
8
9
10`)
}

Aber diese beiden Programme sind ziemlich mühsam zu schreiben. Was wir brauchen, ist eine Möglichkeit, etwas mehrmals zu tun.

Das für Statement

Die Anweisung for ermöglicht es uns, eine Liste von Anweisungen (einen Block) mehrmals zu wiederholen. Wenn wir unser vorheriges Programm mit der Anweisung for umschreiben, sieht das folgendermaßen aus:

package main

import "fmt"

func main() {
    i := 1
    for i <= 10 {
        fmt.Println(i)
        i = i + 1
    }
}

Zuerst erstellen wir eine Variable namens i, in der wir die Zahl speichern, die wir drucken wollen. Dann erstellen wir eine for Schleife, indem wir das Schlüsselwort for verwenden, einen bedingten Ausdruck, der entweder true oder false lautet, und schließlich einen Block zur Ausführung angeben. Die for Schleife funktioniert folgendermaßen:

1. Wir evaluieren (führen aus) den Ausdruck i <= 10 ("i kleiner oder gleich 10"). Wenn dieser Ausdruck wahr ist, führen wir die Anweisungen innerhalb des Blocks aus. Andernfalls springen wir zur nächsten Zeile unseres Programms nach dem Block (in diesem Fall gibt es nach der Schleife for nichts mehr, also beenden wir das Programm).

2. Nachdem wir die Anweisungen innerhalb des Blocks ausgeführt haben, kehren wir in einer Schleife an den Anfang der Anweisung for zurück und wiederholen Schritt 1.

Die Zeile i = i + 1 ist extrem wichtig, denn ohne sie würde i <= 10 immer zu true ausgewertet werden und unser Programm würde nie aufhören (wenn das passiert, nennt man das eine Endlosschleife).

Als Übung wollen wir das Programm wie einen Computer durchgehen:

1. Erstelle eine Variable namens i mit dem Wert 1.

2. Ist i <= 10? Ja.

3. i drucken.

4. Setze i auf i + 1 (i ist jetzt gleich 2).

5. Ist i <= 10? Ja.

6. i drucken.

7. Setze i auf i + 1 (i ist jetzt gleich 3).

8. ...

9. Setze i auf i + 1 (i ist jetzt gleich 11).

10. Ist i <= 10? Nein.

11. Es gibt nichts mehr zu tun, also steig aus.

In anderen Programmiersprachen gibt es viele verschiedene Arten von Schleifen (while, do, until, foreach, ...), aber in Go gibt es nur eine, die auf verschiedene Arten verwendet werden kann. Das vorherige Programm hätte auch so geschrieben werden können:

func main() {
    for i := 1; i <= 10; i++ {
        fmt.Println(i)
    }
}

Der bedingte Ausdruck enthält noch zwei weitere Anweisungen mit Semikolons dazwischen. Zuerst haben wir die Variableninitialisierung, dann haben wir die Bedingung, die jedes Mal überprüft werden soll, und schließlich erhöhen wir die Variable . Das Addieren von 1 zu einer Variablen ist so üblich, dass wir einen speziellen Operator haben (++); ebenso kann das Subtrahieren von 1 mit -- erfolgen.

In späteren Kapiteln werden wir weitere Möglichkeiten sehen, die for Schleife zu nutzen.

Die if-Anweisung

Ändern wir das Programm, das wir gerade geschrieben haben, so ab, dass es nicht nur die Zahlen 1-10 in jeder Zeile ausgibt, sondern auch angibt, ob die Zahl gerade oder ungerade ist oder nicht:

1 odd
2 even
3 odd
4 even
5 odd
6 even
7 odd
8 even
9 odd
10 even

Zuerst brauchen wir eine Möglichkeit, um festzustellen, ob eine Zahl gerade oder ungerade ist oder nicht. Das lässt sich leicht feststellen, indem du die Zahl durch 2 teilst. Wenn nichts übrig bleibt, ist die Zahl gerade, ansonsten ist sie ungerade. Wie finden wir also in Go den Rest nach der Division? Wir benutzen den % Operator. 1 % 2 ist gleich 1, 2 % 2 ist gleich 0, 3 % 2 ist gleich 1, und so weiter.

Als Nächstes brauchen wir eine Möglichkeit, verschiedene Dinge auf der Grundlage einer Bedingung zu tun. Dafür verwenden wir die Anweisung if:

if i % 2 == 0 {
    // even
} else {
    // odd
}

Eine if Anweisung ähnelt einer for Anweisung, da sie eine Bedingung gefolgt von einem Block enthält. if Anweisungen haben auch einen optionalen else Teil. Wenn die Bedingung wahr ist, wird der Block nach der Bedingung ausgeführt; andernfalls wird entweder der Block übersprungen oder, wenn der else Block vorhanden ist, wird dieser Block ausgeführt.

if Aussagen können auch else if Teile haben:

if i % 2 == 0 {
    // divisible by 2
} else if i % 3 == 0 {
    // divisible by 3
} else if i % 4 == 0 {
    // divisible by 4
}

Die Bedingungen werden von oben nach unten geprüft und bei der ersten Bedingung, die wahr ist, wird der zugehörige Block ausgeführt. Keiner der anderen Blöcke wird ausgeführt, selbst wenn ihre Bedingungen ebenfalls erfüllt sind (so ist z. B. die Zahl 8 sowohl durch 4 als auch durch 2 teilbar, aber der Block // divisible by 4 wird nie ausgeführt, weil der Block // divisible by 2 zuerst ausgeführt wird).

Wenn wir alles zusammenzählen, haben wir:

func main() {
    for i := 1; i <= 10; i++ {
        if i % 2 == 0 {
            fmt.Println(i, "even")
        } else {
            fmt.Println(i, "odd")
        }
    }
}

Lass uns durch dieses Programm gehen:

1. Erstelle eine Variable i vom Typ int und gib ihr den Wert 1.

2. Ist i kleiner als oder gleich 10? Ja: Springe zum if Block.

3. Ist der Rest von i ÷ 2 gleich 0? Nein: Springe zum else Block.

4. Drucke i gefolgt von odd.

5. Erhöhe i (die Anweisung nach der Bedingung).

6. Ist i kleiner als oder gleich 10? Ja: Springe zum if Block.

7. Ist der Rest von i ÷ 2 gleich 0? Ja: Springe zum if Block.

8. Drucke i, gefolgt von even, und so weiter, bis i gleich 11 ist.

9. ...

Der Restwert-Operator wird zwar nur selten außerhalb der Grundschule verwendet, erweist sich aber beim Programmieren als sehr nützlich. Er taucht überall auf, vom Zebra Striping von Tabellen bis zur Partitionierung von Datensätzen.

if Anweisungen sind sehr nützlich, aber sie können gelegentlich recht ausführlich sein, daher enthält Go eine verwandte Anweisung: die switch.

Der Schalter Statement

Angenommen, du möchtest ein Programm schreiben, das die englischen Namen für Zahlen ausgibt. Mit dem, was du bisher gelernt hast, könntest du folgendermaßen beginnen:

if i == 0 {
    fmt.Println("Zero")
} else if i == 1 {
    fmt.Println("One")
} else if i == 2 {
    fmt.Println("Two")
} else if i == 3 {
    fmt.Println("Three")
} else if i == 4 {
    fmt.Println("Four")
} else if i == 5 {
    fmt.Println("Five")
}

Da es ziemlich mühsam wäre, ein Programm auf diese Weise zu schreiben, gibt es eine andere Möglichkeit, das gleiche Ergebnis zu erzielen: die Anweisung switch. Wir können unser Programm so umschreiben, dass es wie folgt aussieht:

switch i {
case 0: fmt.Println("Zero")
case 1: fmt.Println("One")
case 2: fmt.Println("Two")
case 3: fmt.Println("Three")
case 4: fmt.Println("Four")
case 5: fmt.Println("Five")
default: fmt.Println("Unknown Number")
}

Eine switch Anweisung beginnt mit dem Schlüsselwort switch, gefolgt von einem Ausdruck (in diesem Fall i) und dann einer Reihe von cases. Der Wert des Ausdrucks wird mit dem Ausdruck verglichen, der auf jedes case Schlüsselwort folgt. Wenn sie gleichwertig sind, werden die Anweisungen, die auf die : folgen, ausgeführt.

Wie bei einer if Anweisung wird jeder Fall von oben nach unten geprüft und der erste Fall, der erfolgreich ist, wird ausgewählt. Ein Schalter unterstützt auch einen Standardfall, der eintritt, wenn keiner der Fälle mit dem Wert übereinstimmt (ähnlich wie else in einer if Anweisung).

for, if und switchsind die wichtigsten Kontrollflussanweisungen. Weitere Anweisungen werden in späteren Kapiteln behandelt.

Übungen

1. Was druckt das folgende Programm?

   i := 10
   if i > 10 {
       fmt.Println("Big")
   } else {
       fmt.Println("Small")
   }

2. Schreibe ein Programm, das alle Zahlen zwischen 1 und 100 ausgibt, die durch 3 teilbar sind (z.B. 3, 6, 9, etc.).

3. Schreibe ein Programm, das die Zahlen von 1 bis 100 ausgibt, aber für Vielfache von drei anstelle der Zahl "Fizz" ausgibt und für Vielfache von fünf "Buzz" ausgibt. Für Zahlen, die sowohl ein Vielfaches von drei als auch von fünf sind, druckst du "FizzBuzz".