Go - Entscheidungsfindung

Einführung in die Entscheidungsfindung in Go

Hallo da draußen, zukünftiger Go-Programmierer! Heute tauchen wir in einen der wichtigsten Aspekte der Programmierung ein: die Entscheidungsfindung. Genau wie im echten Leben müssen unsere Programme Entscheidungen basierend auf bestimmten Bedingungen treffen. In Go haben wir mehrere Werkzeuge zur Verfügung, um diese Entscheidungen zu implementieren. Lassen Sie uns gemeinsam auf diese aufregende Reise gehen!

If-Anweisung: Das Grundelement

Syntax und Struktur

Die if-Anweisung ist das Fundament der Entscheidungsfindung in Go. Sie ermöglicht es uns, einen Block von Code nur auszuführen, wenn eine bestimmte Bedingung wahr ist. Hier ist die grundlegende Struktur:

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

Schauen wir uns ein einfaches Beispiel an:

package main

import "fmt"

func main() {
alter := 18

if alter >= 18 {
fmt.Println("Du bist wahlberechtigt!")
}
}

In diesem Beispiel überprüfen wir, ob das alter 18 oder älter ist. Wenn ja, geben wir eine Nachricht aus. Führe diesen Code aus, und du wirst die Nachricht sehen, weil 18 tatsächlich größer oder gleich 18 ist!

Hinzufügen einer Else-Klausel

Was ist, wenn wir etwas tun möchten, wenn die Bedingung falsch ist? Dann kommt die else-Klausel ins Spiel:

package main

import "fmt"

func main() {
alter := 16

if alter >= 18 {
fmt.Println("Du bist wahlberechtigt!")
} else {
fmt.Println("Entschuldigung, du bist zu jung zum Wählen.")
}
}

Nun ist alter 16, was weniger als 18 ist, daher wird die Nachricht im else-Block ausgegeben.

If-Else If-Else-Kette

Manchmal müssen wir mehrere Bedingungen überprüfen. Wir können if-else-Anweisungen wie folgt verkettet:

package main

import "fmt"

func main() {
punkte := 75

if punkte >= 90 {
fmt.Println("Note A")
} else if punkte >= 80 {
fmt.Println("Note B")
} else if punkte >= 70 {
fmt.Println("Note C")
} else {
fmt.Println("Verbesserung erforderlich")
}
}

Dieses Programm überprüft die punkte und gibt die entsprechende Note aus. Bei 75 Punkten wird es "Note C" ausgeben.

Switch-Anweisung: Der Mehrwege-Entscheidungsgeber

Wenn du mehrere Bedingungen überprüfen musst, insbesondere wenn sie alle dasselbe Variable überprüfen, kann die switch-Anweisung deinen Code sauberer und effizienter machen.

Grundlegende Switch-Syntax

package main

import "fmt"

func main() {
tag := "Montag"

switch tag {
case "Montag":
fmt.Println("Es ist der Anfang der Arbeitswoche!")
case "Freitag":
fmt.Println("TGIF!")
default:
fmt.Println("Es ist ein regulärer Tag.")
}
}

In diesem Beispiel überprüfen wir den Wert von tag und führen die entsprechende Case aus. Der default-Fall wird ausgeführt, wenn keiner der anderen Fälle übereinstimmt.

Switch mit mehreren Fällen

Du kannst auch mehrere Fälle zusammenfassen:

package main

import "fmt"

func main() {
tag := "Samstag"

switch tag {
case "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag":
fmt.Println("Es ist ein Wochentag.")
case "Samstag", "Sonntag":
fmt.Println("Es ist das Wochenende!")
default:
fmt.Println("Ungültiger Tag.")
}
}

Dieser Code wird "Es ist das Wochenende!" ausgeben, weil Samstag einer der Wochentage ist.

Switch ohne Ausdruck

Go ermöglicht es dir, switch ohne einen Ausdruck zu verwenden, was als Alternative zu langen if-else-Ketten dienen kann:

package main

import "fmt"

func main() {
punkte := 85

switch {
case punkte >= 90:
fmt.Println("Note A")
case punkte >= 80:
fmt.Println("Note B")
case punkte >= 70:
fmt.Println("Note C")
default:
fmt.Println("Verbesserung erforderlich")
}
}

Dies wird "Note B" ausgeben, weil 85 größer oder gleich 80 ist.

Bedingte Operatoren

Um unsere Bedingungen leistungsfähiger zu machen, verwenden wir bedingte Operatoren. Hier ist eine Tabelle der häufigsten:

Operator	Beschreibung	Beispiel
==	Gleich	a == b
!=	Ungleich	a != b
<	Kleiner als	a < b
>	Größer als	a > b
<=	Kleiner oder gleich	a <= b
>=	Größer oder gleich	a >= b
&&	Logisches AND	a && b
||	Logisches OR	a || b
!	Logisches NICHT	!a

Schauen wir uns diese in Aktion an:

package main

import "fmt"

func main() {
alter := 25
hatFuehrerschein := true

if alter >= 18 && hatFuehrerschein {
fmt.Println("Du darfst ein Auto fahren!")
} else if alter >= 18 && !hatFuehrerschein {
fmt.Println("Du bist alt genug, aber du brauchst einen Fuehrerschein.")
} else {
fmt.Println("Du bist zu jung zum Fahren.")
}
}

Dieses Programm überprüft sowohl das alter als auch, ob die Person einen hatFuehrerschein, um zu bestimmen, ob sie fahren darf.

Schlussfolgerung

Entscheidungsfindung ist ein grundlegender Begriff in der Programmierung, und Go stellt uns mächtige Werkzeuge zur Verfügung, um sie zu implementieren. Denke daran, Übung macht den Meister! Versuche, deine eigenen Programme mit if, switch und verschiedenen bedingten Operatoren zu erstellen.

Während du deine Reise in Go fortsetzt, wirst du diese Konstrukte häufig verwenden. Sie sind die Bausteine der Logik in deinen Programmen, die tuoem Code helfen, kluge Entscheidungen basierend auf verschiedenen Bedingungen zu treffen.

Weiter codieren, weiter lernen und vor allem: Viel Spaß mit Go!

Credits: Image by storyset