Simulieren einer Do-While Schleife in Golang

Key Takeaways

1. Go hat keine eingebaute do...while-Schleife, aber sie kann mit einer for-Schleife nachgebildet werden.
2. Eine for-Schleife mit einer anfänglichen true-Bedingung stellt sicher, dass sie mindestens einmal ausgeführt wird.
3. Eine unendliche for-Schleife mit break kann ebenfalls das do...while-Verhalten simulieren.

In Go gibt es keine eingebaute do...while-Schleife, wie sie in einigen anderen Programmiersprachen vorkommt. Sie können jedoch eine ähnliche Funktionalität mit einer for-Schleife erreichen. Ein üblicher Ansatz ist die Verwendung einer for-Schleife mit einer Bedingung, die sicherstellt, dass die Schleife mindestens einmal ausgeführt wird. Hier ist, wie Sie es implementieren können:

package main

import "fmt"

func main() {
    var input int
    for ok := true; ok; ok = (input != 2) {
        fmt.Println("Drücken Sie 1 zum Ausführen")
        fmt.Println("Drücken Sie 2 zum Beenden")
        _, err := fmt.Scanln(&input)
        if err != nil {
            fmt.Println("Ungültige Eingabe")
            break
        }

        switch input {
        case 1:
            fmt.Println("Wird ausgeführt...")
        case 2:
            fmt.Println("Wird beendet...")
            // Die Schleife wird beim nächsten Iterationscheck natürlich beendet
        default:
            fmt.Println("Ungültige Auswahl")
        }
    }
}

In diesem Beispiel:

• Wir deklarieren eine Variable input, um die Benutzereingabe zu speichern.
• Die for-Schleife beginnt mit ok, das auf true gesetzt ist, wodurch sichergestellt wird, dass die Schleife mindestens einmal ausgeführt wird.
• Nach jeder Iteration wird ok basierend auf der Bedingung (input != 2) aktualisiert. Wenn der Benutzer 2 eingibt, wird ok zu false und die Schleife wird beendet.
• Innerhalb der Schleife fordern wir den Benutzer auf und lesen seine Eingabe mit fmt.Scanln ein.
• Eine switch-Anweisung behandelt verschiedene Fälle basierend auf der Eingabe des Benutzers.

Dieses Muster ahmt effektiv eine do...while-Schleife nach und stellt sicher, dass der Code innerhalb der Schleife mindestens einmal ausgeführt wird, bevor die Bedingung ausgewertet wird.

Alternativ können Sie eine unendliche for-Schleife mit einer break-Anweisung verwenden, um die Beendigung der Schleife zu steuern:

package main

import "fmt"

func main() {
    var input int
    for {
        fmt.Println("Drücken Sie 1 zum Ausführen")
        fmt.Println("Drücken Sie 2 zum Beenden")
        _, err := fmt.Scanln(&input)
        if err != nil {
            fmt.Println("Ungültige Eingabe")
            continue
        }

        switch input {
        case 1:
            fmt.Println("Wird ausgeführt...")
        case 2:
            fmt.Println("Wird beendet...")
            break // Beende die Schleife
        default:
            fmt.Println("Ungültige Auswahl")
        }
    }
}

In dieser Version:

• Wir verwenden eine unendliche for-Schleife: for { ... }.
• Die break-Anweisung wird verwendet, um die Schleife zu beenden, wenn der Benutzer 2 eingibt.
• Wenn die Eingabe ungültig ist, springt die continue-Anweisung zur nächsten Iteration.

Beide Ansätze sind in Go gültig und können verwendet werden, um eine do...while-Schleife zu simulieren, abhängig von Ihren spezifischen Anforderungen und Ihrem Programmierstil.

FAQs

Warum hat Go keine eingebaute do...while-Schleife?

Go bevorzugt Einfachheit und Konsistenz und verwendet for als einzige Schleifenkonstruktion.

Wie kann ich sicherstellen, dass meine Schleife mindestens einmal ausgeführt wird?

Verwenden Sie for ok := true; ok; ok = Bedingung oder eine unendliche for-Schleife mit einer break-Anweisung.

Welcher Ansatz ist besser, um do...while nachzuahmen?

Das hängt davon ab – verwenden Sie for ok := true für Klarheit oder eine unendliche Schleife mit break für Flexibilität.

---

Wir sind Leapcell, Ihre erste Wahl für das Hosten von Go-Projekten.

Leapcell ist die Next-Gen Serverless-Plattform für Webhosting, Async-Aufgaben und Redis:

Multi-Language-Unterstützung

• Entwickeln Sie mit Node.js, Python, Go oder Rust.

Stellen Sie unbegrenzt Projekte kostenlos bereit

• Zahlen Sie nur für die Nutzung – keine Anfragen, keine Gebühren.

Unschlagbare Kosteneffizienz

• Pay-as-you-go ohne Leerlaufgebühren.
• Beispiel: 25 $ unterstützen 6,94 Millionen Anfragen bei einer durchschnittlichen Antwortzeit von 60 ms.

Optimierte Entwicklererfahrung

• Intuitive Benutzeroberfläche zur mühelosen Einrichtung.
• Vollautomatische CI/CD-Pipelines und GitOps-Integration.
• Echtzeitmetriken und -protokollierung für umsetzbare Erkenntnisse.

Mühelose Skalierbarkeit und hohe Leistung

• Automatische Skalierung zur einfachen Bewältigung hoher Parallelität.
• Null Betriebsaufwand – konzentrieren Sie sich einfach auf das Bauen.

Erfahren Sie mehr in der Dokumentation!

Folgen Sie uns auf X: @LeapcellHQ