TOC

So schreiben Sie bedingte Anweisungen in Go

Einführung

Bedingte Anweisungen sind Teil jeder Programmiersprache. Mit bedingten Anweisungen können wir Code haben, der je nach den Bedingungen des Programms zu diesem Zeitpunkt manchmal ausgeführt wird und zu anderen Zeiten nicht ausgeführt wird.

Wenn wir jede Anweisung eines Programms vollständig ausführen, bitten wir das Programm nicht, bestimmte Bedingungen zu bewerten. Mithilfe von bedingten Anweisungen können Programme ermitteln, ob bestimmte Bedingungen erfüllt sind, und dann erfahren, was als Nächstes zu tun ist.

Schauen wir uns einige Beispiele an, in denen wir bedingte Anweisungen verwenden würden:

  • Wenn die Schülerin bei ihrem Test mehr als 65% erhält, geben Sie an, dass ihre Note bestanden wurde. Wenn nicht, melde, dass ihre Note nicht bestanden hat.

  • Wenn er Geld auf seinem Konto hat, berechnen Sie die Zinsen. Wenn dies nicht der Fall ist, wird eine Strafgebühr erhoben.

  • Wenn sie 10 Orangen oder mehr kaufen, berechnen sie einen Rabatt von 5%; Wenn sie weniger kaufen, dann nicht.

Durch Auswerten der Bedingungen und Zuweisen von Code zur Ausführung basierend darauf, ob diese Bedingungen erfüllt sind oder nicht, schreiben wir bedingten Code.

In diesem Lernprogramm werden Sie durch das Schreiben von bedingten Anweisungen in der Programmiersprache Go geführt.

If-Anweisungen

Wir beginnen mit der Anweisung + if +, die bewertet, ob eine Anweisung wahr oder falsch ist, und führen den Code nur für den Fall aus, dass die Anweisung wahr ist.

Öffnen Sie in einem Nur-Text-Editor eine Datei und schreiben Sie den folgenden Code:

grade.go

package main

import "fmt"

func main() {
   grade := 70

   if grade >= 65 {
       fmt.Println("Passing grade")
   }
}

Mit diesem Code haben wir die Variable "+ grade " und geben ihr den ganzzahligen Wert " 70 ". Wir verwenden dann die Anweisung " if ", um zu bewerten, ob die variable Note größer oder gleich ("> = ") zu " 65 " ist. Wenn dies nicht der Fall ist, werden wir das Programm auffordern, die https://www.digitalocean.com/community/tutorials/an-einführung-zum-arbeiten-mit-Strings-in[string] ` auszudrucken Bestehen der Note + `.

Speichern Sie das Programm als + grade.go + und führen Sie es unter https://www.digitalocean.com/community/tutorial_series/how-to-install-and-set-up-a-local-programming-environment-for aus -go [lokale Programmierumgebung aus einem Terminalfenster] mit dem Befehl + go run grade.go +.

In diesem Fall erfüllt die Note 70 die Bedingung größer oder gleich 65, sodass Sie die folgende Ausgabe erhalten, sobald Sie das Programm ausführen:

OutputPassing grade

Ändern wir nun das Ergebnis dieses Programms, indem wir den Wert der Variablen "+ grade " in " 60 +" ändern:

grade.go

package main

import "fmt"

func main() {
   grade :=

   if grade >= 65 {
       fmt.Println("Passing grade")
   }
}

Wenn wir diesen Code speichern und ausführen, erhalten wir keine Ausgabe, da die Bedingung nicht erfüllt war und wir das Programm nicht angewiesen haben, eine andere Anweisung auszuführen.

Um ein weiteres Beispiel zu geben, lassen Sie uns berechnen, ob der Kontostand eines Bankkontos unter 0 liegt. Erstellen wir eine Datei mit dem Namen "+ account.go +" und schreiben das folgende Programm:

account.go

package main

import "fmt"

func main() {
   balance := -5

   if balance < 0 {
       fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
   }
}

Wenn wir das Programm mit "+ go run account.go +" ausführen, erhalten wir die folgende Ausgabe:

OutputBalance is below 0, add funds now or you will be charged a penalty.

Im Programm haben wir die Variable "+ balance " mit dem Wert " -5 " initialisiert, der kleiner als 0 ist. Da der Saldo die Bedingung der Anweisung " if " (" balance <0 +") erfüllt, erhalten wir nach dem Speichern und Ausführen des Codes die Zeichenfolgenausgabe. Auch hier erhalten wir keine Ausgabe, wenn wir den Saldo auf 0 oder eine positive Zahl ändern.

Andere Aussagen

Es ist wahrscheinlich, dass wir wollen, dass das Programm etwas tut, auch wenn eine "+ if +" - Anweisung "false" ergibt. In unserem Notenbeispiel möchten wir die Ausgabe unabhängig davon, ob die Note bestanden wurde oder nicht.

Dazu fügen wir der obigen Notenbedingung eine + else + -Anweisung hinzu, die wie folgt aufgebaut ist:

grade.go

package main

import "fmt"

func main() {
   grade := 60

   if grade >= 65 {
       fmt.Println("Passing grade")
   } else {
       fmt.Println("Failing grade")
   }
}

Da die Klassenvariable den Wert "+ 60 " hat, wird die Anweisung " if " als "false" ausgewertet, sodass das Programm nicht " Passing grade +" ausgibt. Die folgende + else + -Anweisung weist das Programm an, trotzdem etwas zu tun.

Wenn wir das Programm speichern und ausführen, erhalten wir die folgende Ausgabe:

OutputFailing grade

Wenn wir dann das Programm umschreiben, um der Note einen Wert von "+ 65 " oder höher zu geben, erhalten wir stattdessen die Ausgabe " Bestehen der Note +".

Um dem Bankkontobeispiel ein "+ else +" - Statement hinzuzufügen, schreiben wir den Code wie folgt um:

account.go

package main

import "fmt"

func main() {
   balance := 522

   if balance < 0 {
       fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
   } else {
       fmt.Println("Your balance is 0 or above.")
   }
}
OutputYour balance is 0 or above.

Hier haben wir den Variablenwert "+ balance " in eine positive Zahl geändert, sodass die Anweisung " else " ausgegeben wird. Um die erste " if +" - Anweisung zu drucken, können wir den Wert in eine negative Zahl umschreiben.

Indem Sie eine "+ if " - Anweisung mit einer " else " - Anweisung kombinieren, erstellen Sie eine zweiteilige bedingte Anweisung, die den Computer anweist, bestimmten Code auszuführen, unabhängig davon, ob die " if +" - Bedingung erfüllt ist oder nicht.

Else if-Anweisungen

Bisher haben wir eine Boolean -Option für bedingte Anweisungen vorgestellt, wobei jede "+ if " - Anweisung entweder "true" oder "true" ergibt falsch. In vielen Fällen möchten wir ein Programm, das mehr als zwei mögliche Ergebnisse bewertet. Dazu verwenden wir eine * else if * -Anweisung, die in Go als ` else if ` geschrieben ist. Die " else if " - oder "else if" -Anweisung sieht aus wie die " if +" -Anweisung und bewertet eine andere Bedingung.

Im Bankkontoprogramm möchten wir möglicherweise drei diskrete Ausgaben für drei verschiedene Situationen haben:

  • Der Saldo liegt unter 0

  • Der Saldo ist gleich 0

  • Der Saldo liegt über 0

Die Anweisung + else if + wird wie folgt zwischen der Anweisung + if + und der Anweisung + else + eingefügt:

account.go

package main

import "fmt"

func main() {
   balance := 522

   if balance < 0 {
       fmt.Println("Balance is below 0, add funds now or you will be charged a penalty.")
   } else if balance == 0 {
       fmt.Println("Balance is equal to 0, add funds soon.")
   } else {
       fmt.Println("Your balance is 0 or above.")
   }
}

Jetzt gibt es drei mögliche Ausgaben, die auftreten können, wenn wir das Programm ausführen:

  • Wenn die Variable "+ balance " gleich " 0 " ist, erhalten wir die Ausgabe der Anweisung " else if +".

  • Wenn die Variable "+ balance " auf eine positive Zahl gesetzt ist, erhalten wir die Ausgabe der Anweisung " else " (" Ihr Kontostand ist 0 oder höher. +").

  • Wenn die Variable "+ balance " auf eine negative Zahl gesetzt ist, ist die Ausgabe die Zeichenfolge aus der " if " - Anweisung (" balance ist unter 0", fügen Sie jetzt Geld hinzu, oder Sie werden mit einer Strafe belastet + ").

Was ist, wenn wir mehr als drei Möglichkeiten haben wollen? Wir können dies tun, indem wir mehr als eine "+ else if +" - Anweisung in unseren Code schreiben.

Schreiben wir den Code im Programm "+ grade.go +" so, dass es einige Buchstabengrade gibt, die Bereichen numerischer Grade entsprechen:

  • 90 oder höher entspricht einer A-Note

  • 80-89 entspricht einer B-Note

  • 70-79 entspricht einer C-Note

  • 65-69 entspricht einer D-Note

  • 64 oder weniger entspricht einer F-Note

Um diesen Code auszuführen, benötigen wir eine "+ if " - Anweisung, drei " else if " - Anweisungen und eine " else +" - Anweisung, die alle fehlgeschlagenen Fälle behandelt.

Lassen Sie uns den Code aus dem vorhergehenden Beispiel neu schreiben, um Zeichenfolgen zu erhalten, mit denen die einzelnen Buchstabenklassen gedruckt werden. Wir können unsere + else + -Anweisung beibehalten.

grade.go

package main

import "fmt"

func main() {
   grade := 60

   if grade >= 90 {
       fmt.Println("A grade")
   } else if grade >= 80 {
       fmt.Println("B grade")
   } else if grade >= 70 {
       fmt.Println("C grade")
   } else if grade >= 65 {
       fmt.Println("D grade")
   } else {
       fmt.Println("Failing grade")
   }
}

Da "+ else if +" - Anweisungen der Reihe nach ausgewertet werden, können wir unsere Anweisungen ziemlich einfach halten. Dieses Programm führt die folgenden Schritte aus:

  1. Wenn die Note größer als 90 ist, gibt das Programm "+ A Note +" aus. Wenn die Note kleiner als 90 ist, fährt das Programm mit der nächsten Anweisung fort.

  2. Wenn die Note größer oder gleich 80 ist, gibt das Programm "+ B Note +" aus. Wenn die Note 79 oder weniger ist, fährt das Programm mit der nächsten Anweisung fort.

  3. Wenn die Note größer oder gleich 70 ist, gibt das Programm "+ C Note +" aus. Wenn die Note 69 oder weniger ist, fährt das Programm mit der nächsten Anweisung fort.

  4. Wenn die Note größer oder gleich 65 ist, gibt das Programm "+ D Note +" aus. Wenn die Note 64 oder niedriger ist, fährt das Programm mit der nächsten Anweisung fort.

  5. Das Programm gibt "+ Bewertung nicht bestanden +" aus, da nicht alle der oben genannten Bedingungen erfüllt wurden.

Verschachtelte If-Anweisungen

Wenn Sie mit den Anweisungen "+ if", "+ else if" und "+ else" vertraut sind, können Sie mit verschachtelten bedingten Anweisungen fortfahren. Wir können geschachtelte "+ if" -Anweisungen für Situationen verwenden, in denen wir nach einer Sekundärbedingung suchen möchten, wenn die erste Bedingung als wahr ausgeführt wird. Dafür können wir eine if-else-Anweisung innerhalb einer anderen if-else-Anweisung haben. Sehen wir uns die Syntax einer verschachtelten "+ if +" - Anweisung an:

if statement1 { // outer if statement
   fmt.Println("true")

   if nested_statement { // nested if statement
       fmt.Println("yes")
   } else { // nested else statement
       fmt.Println("no")
   }

} else { // outer else statement
   fmt.Println("false")
}

Einige mögliche Ausgaben können sich aus diesem Code ergeben:

  • Wenn "+ Anweisung1 " als wahr ausgewertet wird, bewertet das Programm, ob das " verschachtelte_Anweisung +" auch als wahr ausgewertet wird. Wenn beide Fälle zutreffen, lautet die Ausgabe:

_ _

Outputtrue
yes

_ _

  • Wenn jedoch "+ Anweisung1 " als wahr ausgewertet wird, " verschachtelte_Anweisung +" jedoch als falsch ausgewertet wird, lautet die Ausgabe:

_ _

Outputtrue
no

_ _

  • Und wenn "+ statement1 " false ergibt, wird die verschachtelte if-else-Anweisung nicht ausgeführt, sodass die " else +" - Anweisung alleine ausgeführt wird, und die Ausgabe lautet:

_ _

Outputfalse

_ _

Es können auch mehrere "+ if" -Anweisungen im gesamten Code verschachtelt sein:

if statement1 { // outer if
   fmt.Println("hello world")

   if nested_statement1 { // first nested if
       fmt.Println("yes")

   } else if nested_statement2 { // first nested else if
       fmt.Println("maybe")

   } else { // first nested else
       fmt.Println("no")
   }

} else if statement2 { // outer else if
   fmt.Println("hello galaxy")

   if nested_statement3 { // second nested if
       fmt.Println("yes")
   } else if nested_statement4 { // second nested else if
       fmt.Println("maybe")
   } else { // second nested else
       fmt.Println("no")
   }

} else { // outer else
   statement("hello universe")
}

In diesem Code gibt es eine geschachtelte "+ if" -Anweisung in jeder "+ if" -Anweisung zusätzlich zur "+ else if" -Anweisung. Dies ermöglicht mehr Optionen innerhalb jeder Bedingung.

Schauen wir uns ein Beispiel für verschachtelte "+ if " - Anweisungen mit unserem " grade.go " - Programm an. Wir können prüfen, ob eine Note zuerst besteht (größer oder gleich 65%) und dann bewerten, welcher Buchstabennote die numerische Note entsprechen sollte. Wenn die Note nicht bestanden wird, müssen wir die Buchstabennoten nicht durchlaufen. Stattdessen kann das Programm melden, dass die Note nicht bestanden wird. Unser modifizierter Code mit der verschachtelten " if +" - Anweisung sieht folgendermaßen aus:

grade.go

package main

import "fmt"

func main() {
   grade := 92
   if grade >= 65 {
       fmt.Print("Passing grade of: ")

       if grade >= 90 {
           fmt.Println("A")

       } else if grade >= 80 {
           fmt.Println("B")

       } else if grade >= 70 {
           fmt.Println("C")

       } else if grade >= 65 {
           fmt.Println("D")
       }

   } else {
       fmt.Println("Failing grade")
   }
}

Wenn wir den Code mit der Variable "+ grade " ausführen, die auf den ganzzahligen Wert " 92 " gesetzt ist, ist die erste Bedingung erfüllt und das Programm gibt " Passing grade of: " aus. Als nächstes wird geprüft, ob die Note größer oder gleich 90 ist, und da diese Bedingung ebenfalls erfüllt ist, wird " A +" ausgegeben.

Wenn wir den Code mit der Variable "+ grade " auf " 60 " ausführen, ist die erste Bedingung nicht erfüllt, sodass das Programm die verschachtelten " if " - Anweisungen überspringt und zur " else " - Anweisung wechselt , wobei das Programm " Fehlnote +" ausgibt.

Wir können dem natürlich noch weitere Optionen hinzufügen und eine zweite Schicht verschachtelter if-Anweisungen verwenden. Vielleicht wollen wir die Noten A +, A und A- getrennt bewerten. Wir können dies tun, indem wir zuerst prüfen, ob die Note bestanden wird, dann prüfen, ob die Note 90 oder höher ist, und dann prüfen, ob die Note für ein A + über 96 liegt:

grade.go

...
if grade >= 65 {
   fmt.Print("Passing grade of: ")

   if grade >= 90 {
       if grade > 96 {
           fmt.Println("A+")

       } else if grade > 93 && grade <= 96 {
           fmt.Println("A")

       } else {
           fmt.Println("A-")
       }
...

In diesem Code führt das Programm für eine Variable "+ grade ", die auf " 96 +" gesetzt ist, Folgendes aus:

  1. Überprüfen Sie, ob die Note größer oder gleich 65 ist (wahr)

  2. Ausdrucken + Bestehen der Note: +

  3. Überprüfen Sie, ob die Note größer oder gleich 90 ist (wahr)

  4. Überprüfen Sie, ob die Note größer als 96 ist (falsch)

  5. Überprüfen Sie, ob die Note größer als 93 und auch kleiner oder gleich 96 (wahr) ist.

  6. Drucken Sie + A +

  7. Belassen Sie diese verschachtelten bedingten Anweisungen und fahren Sie mit dem verbleibenden Code fort

Die Ausgabe des Programms für eine Note von 96 sieht also so aus:

OutputPassing grade of: A

Verschachtelte "+ if +" - Anweisungen bieten die Möglichkeit, Ihrem Code mehrere spezifische Bedingungen hinzuzufügen.

Fazit

Durch die Verwendung von bedingten Anweisungen wie der "+ if +" - Anweisung haben Sie eine bessere Kontrolle über die Ausführung Ihres Programms. Bedingte Anweisungen weisen das Programm an, zu bewerten, ob eine bestimmte Bedingung erfüllt ist. Wenn die Bedingung erfüllt ist, wird ein bestimmter Code ausgeführt. Wenn sie jedoch nicht erfüllt ist, wird das Programm weiter zu einem anderen Code verschoben.

Verwenden Sie zum Üben bedingter Anweisungen verschiedene operators, um sich mit bedingten Anweisungen vertraut zu machen.

Related