1 Übersicht über bedingte Anweisungen

Bedingte Anweisungen sind wichtige Werkzeuge zur Steuerung des logischen Ablaufs von Programmen in der Programmierung. In Golang sind bedingte Anweisungen ähnlich wie in anderen Programmiersprachen, haben aber ihre eigenen Merkmale. Sie ermöglichen es uns, basierend auf wahren oder falschen Bedingungen zu entscheiden, welcher Code ausgeführt werden soll, was die Flexibilität und Wartbarkeit des Codes erheblich erhöht.

2 if-Anweisung

2.1 Grundlegende Verwendung der if-Anweisung

Die if-Anweisung ist die grundlegendste bedingte Anweisung in der Go-Sprache. Ihre Syntax ist wie folgt:

if Bedingung {
    // Code, der ausgeführt wird, wenn die Bedingung wahr ist
}

Hier ist ein einfaches Beispiel:

package main

import "fmt"

func main() {
    x := 10
    if x > 5 {
        fmt.Println("x ist größer als 5")
    }
}

Dieser Code überprüft, ob x größer als 5 ist, und wenn dies der Fall ist, führt er die Druckoperation aus.

2.2 Bedingte Ausdrücke

Bedingte Ausdrücke bestehen aus Vergleichsoperatoren (wie ==, !=, <, >, <=, >=) und logischen Operatoren (wie && (UND), || (ODER), ! (NICHT)).

Um beispielsweise zu überprüfen, ob eine Variable in einem bestimmten Bereich liegt:

y := 20
if y >= 10 && y <= 30 {
    fmt.Println("y liegt zwischen 10 und 30")
}

Der obige bedingte Ausdruck verwendet den logischen Operator &&, um sicherzustellen, dass der Wert von y zwischen 10 und 30 liegt.

2.3 if...else und else if-Struktur

Wenn die if-Bedingung nicht erfüllt ist, können wir else verwenden, um einen alternativen Codeblock auszuführen. Das else if ermöglicht uns, mehrere Bedingungen zu überprüfen. Hier ist ein Beispiel:

score := 88

if score >= 90 {
    fmt.Println("Ausgezeichnet")
} else if score >= 80 {
    fmt.Println("Gut")
} else if score >= 70 {
    fmt.Println("Durchschnitt")
} else {
    fmt.Println("Unterdurchschnittlich")
}

Dieser Code gibt basierend auf dem Wert von score unterschiedliche Bewertungen aus.

3 switch-Anweisung

3.1 Grundlegende Syntax des switch

Die switch-Anweisung ist eine prägnante bedingte Verzweigungsanweisung, die besonders geeignet ist, wenn mehrere Werte ausgewertet werden müssen. Die grundlegende Syntax der switch-Anweisung lautet wie folgt:

switch Ausdruck {
case Wert1:
    // Code, der ausgeführt wird, wenn Wert1 übereinstimmt
case Wert2:
    // Code, der ausgeführt wird, wenn Wert2 übereinstimmt
default:
    // Code, der standardmäßig ausgeführt wird
}

Wenn der Wert des Ausdrucks dem nachfolgenden Wert von case entspricht, wird der jeweilige Codeblock ausgeführt.

3.2 switch Fallthrough

In der switch-Anweisung von Go erfolgt jeder Zweig standardmäßig nicht automatisch zum nächsten Fall, es sei denn, das Schlüsselwort fallthrough wird verwendet.

switch num {
case 1:
    fmt.Println("Eins")
    fallthrough
case 2:
    fmt.Println("Zwei")
default:
    fmt.Println("Weder Eins noch Zwei")
}

Im obigen Code, wenn num 1 ist, wird trotz Übereinstimmung mit case 1 aufgrund des Vorhandenseins des Schlüsselworts fallthrough das Programm fortgesetzt, um den Code in case 2 auszuführen und "Zwei" auszugeben.

3.3 Typverzweigung und benutzerdefinierte Verzweigung

Die switch-Anweisung unterstützt auch Verzweigungen basierend auf Variablentypen, die als Typverzweigung bekannt sind. Darüber hinaus können komplexere benutzerdefinierte Verzweigungsbedingungen erstellt werden.

Beispiel für Typverzweigung:

var i interface{} = 1

switch i.(type) {
case int:
    fmt.Println("i ist eine ganze Zahl")
case float64:
    fmt.Println("i ist eine float64-Zahl")
default:
    fmt.Println("i ist ein anderer Typ")
}

Benutzerdefinierte Verzweigungsbedingungen können geschrieben werden, um komplexere bedingte Beurteilungen nach Bedarf durchzuführen.

4 Praktische Übung

In diesem Abschnitt vertiefen wir unser Verständnis und die Anwendung von bedingten Anweisungen in Golang durch konkrete Beispiele. Durch praktische Programmieraufgaben werden Sie sicherer im Umgang mit if- und switch-Anweisungen, um reale Probleme zu lösen.

Notenrechner

Lass uns einen einfachen Notenrechner schreiben. Dieses Programm wird die entsprechende Note basierend auf der vom Benutzer eingegebenen Punktzahl bestimmen und ausgeben. Die Bewertungskriterien sind wie folgt:

  • A für Punktzahlen von 90 und höher
  • B für Punktzahlen zwischen 80 und 89
  • C für Punktzahlen zwischen 70 und 79
  • D für Punktzahlen zwischen 60 und 69
  • F für Punktzahlen unter 60

Wir können entweder eine if-Anweisung oder eine switch-Anweisung verwenden, um diese Funktionalität zu implementieren. Zuerst schauen wir uns ein Beispiel mit einer if-Anweisung an:

package main

import (
	"fmt"
)

func main() {
	var punktzahl int
	fmt.Print("Bitte gib die Punktzahl ein: ")
	fmt.Scan(&punktzahl)

	if punktzahl >= 90 {
		fmt.Println("Note: A")
	} else if punktzahl >= 80 {
		fmt.Println("Note: B")
	} else if punktzahl >= 70 {
		fmt.Println("Note: C")
	} else if punktzahl >= 60 {
		fmt.Println("Note: D")
	} else {
		fmt.Println("Note: F")
	}
}

In diesem Code deklarieren wir zunächst eine Variable punktzahl, um die vom Benutzer eingegebene Punktzahl zu speichern. Wir verwenden die Funktion fmt.Scan, um die Eingabe des Benutzers zu erhalten. Anschließend verwenden wir mehrere if- und else if-Anweisungen, um die entsprechende Note für die Punktzahl zu bestimmen, und verwenden die Funktion fmt.Println, um die Note auszugeben.

Als nächstes schauen wir uns ein Beispiel mit einer switch-Anweisung an:

package main

import (
	"fmt"
)

func main() {
	var punktzahl int
	fmt.Print("Bitte gib die Punktzahl ein: ")
	fmt.Scan(&punktzahl)

	switch {
	case punktzahl >= 90:
		fmt.Println("Note: A")
	case punktzahl >= 80:
		fmt.Println("Note: B")
	case punktzahl >= 70:
		fmt.Println("Note: C")
	case punktzahl >= 60:
		fmt.Println("Note: D")
	default:
		fmt.Println("Note: F")
	}
}

In dem Beispiel mit der switch-Anweisung ist die Code-Struktur prägnanter und klarer. Wir müssen nicht viele aufeinander folgende if- und else if-Anweisungen verwenden; stattdessen spezifizieren wir die Bedingungen in jedem case nach dem switch. Die Punktzahl, die nicht mit der Bedingung des vorherigen case übereinstimmt, wird automatisch zum nächsten case weitergeleitet, bis sie dem entsprechenden Zweig entspricht oder das default-Case erreicht, das die Note F ausgibt.

Jetzt, da du gelernt hast, wie man if- und switch-Anweisungen für bedingte Überprüfungen verwendet, versuche, dein eigenes Programm zu schreiben und zu üben, um dein Verständnis zu vertiefen.

Im nächsten Abschnitt werden wir weitere praktische Probleme einführen, um dir zu helfen, deine Beherrschung der bedingten Anweisungen in Golang zu festigen.

Bitte beachte, dass der obige Code zu Lehrzwecken ist. Bei der Verwendung in praktischen Anwendungen sollten Faktoren wie die Benutzerinteraktion und Fehlerbehandlung berücksichtigt werden, um ihn robuster zu gestalten.