Die Prozesssteuerung umfasst drei Hauptkategorien: bedingte Beurteilung, Schleifensteuerung und bedingungsloser Sprung.
Wenn
if ist vielleicht die häufigste unter verschiedenen Programmiersprachen. Die Syntax lässt sich wie folgt zusammenfassen: Wenn die Bedingung erfüllt ist, tue etwas, andernfalls tue etwas anderes.
Wie im folgenden Code gezeigt, sind in der if-bedingten Urteilsanweisung in Go keine Klammern erforderlich
if x > 10 {
fmt.Println("x is greater than 10")
} else {
fmt.Println("x is less than 10")
}
Eine weitere leistungsstarke Funktion von Gos if besteht darin, dass es die Deklaration einer Variablen in einer bedingten Urteilsanweisung ermöglicht . Der Gültigkeitsbereich dieser Variablen kann nur innerhalb des bedingten Logikblocks liegen und funktioniert nicht an anderer Stelle, wie unten gezeigt
// 计算获取值 x, 然后根据 x 返回的大小，判断是否大于 10 。
if x := computedValue(); x > 10 {
fmt.Println("x is greater than 10")
} else {
fmt.Println("x is less than 10")
}
// 这个地方如果这样调用就编译出错了，因为 x 是条件里面的变量
fmt.Println(x)
Wenn mehrere Bedingungen vorliegen, ist es wie folgt:
if integer == 3 {
fmt.Println("The integer is equal to 3")
} else if integer < 3 {
fmt.Println("The integer is less than 3")
} else {
fmt.Println("The integer is greater than 3")
}
gehe zu
Go hat die goto-Anweisung – verwenden Sie sie mit Bedacht. Mit goto springen Sie zu einer Beschriftung, die innerhalb der aktuellen Funktion definiert werden muss. Betrachten Sie beispielsweise eine Schleife wie diese:
func myFunc() {
i := 0
Here: // 这行的第一个词，以冒号结束作为标签
println(i)
i++
goto Here // 跳转到 Here 去
}
Bei Tag-Namen muss die Groß-/Kleinschreibung beachtet werden.
für
Die leistungsstärkste Steuerlogik in Go ist for, mit der Daten in einer Schleife gelesen und als Weile zur Steuerung der Logik verwendet werden können. Außerdem kann sie iterativ arbeiten. Seine Syntax ist wie folgt:
for expression1; expression2; expression3 {
//...
}
Ausdruck1, Ausdruck2 und Ausdruck3 sind alles Ausdrücke, wobei Ausdruck1 und Ausdruck3 Variablendeklarationen oder
Rückgabewerte von Funktionsaufrufen sind, Ausdruck2 für die bedingte Beurteilung verwendet wird, Ausdruck1 vor dem Beginn der Schleife aufgerufen wird und Ausdruck3
am Ende jedes Zyklus aufgerufen wird.
Ein Beispiel ist nützlicher als das obige, also schauen wir uns das folgende Beispiel an:
package main
import "fmt"
func main(){
sum := 0;
for index:=0; index < 10 ; index++ {
sum += index
}
fmt.Println("sum is equal to ", sum)
}
// 输出： sum is equal to 45
Manchmal sind mehrere Zuweisungsoperationen erforderlich. Da es in Go keine ","-Operation gibt, können Sie die parallele Zuweisung i, j = i+1, j-1 verwenden. Manchmal, wenn wir Ausdruck1 und Ausdruck3 ignorieren
:
sum := 1
for ; sum < 1000; {
sum += sum
}
Darunter; kann auch weggelassen werden, dann wird daraus der folgende Code. Kommt Ihnen das bekannt vor? Ja, das ist es, was while tut.
sum := 1
for sum < 1000 {
sum += sum
}
Es gibt zwei Schlüsseloperationen in der Schleife: Unterbrechung und Fortsetzung. Die Unterbrechungsoperation besteht darin, aus der aktuellen Schleife zu springen, und die Fortsetzungsoperation besteht darin, diese Schleife zu überspringen. Wenn die Verschachtelung
zu tief ist, kann Break mit Beschriftungen verwendet werden, d. h. es wird an die durch die Beschriftung angegebene Stelle gesprungen. Einzelheiten finden Sie im folgenden Beispiel:
for index := 10; index>0; index-- {
if index == 5{
break // 或者 continue
}
fmt.Println(index)
}
// break 打印出来 10 、 9 、 8 、 7 、 6
// continue 打印出来 10 、 9 、 8 、 7 、 6 、 4 、 3 、 2 、 1
Auf break und continue können auch Beschriftungen folgen, um in einer Mehrfachschleife zur äußeren Schleife zu springen.
for kombiniert mit range kann zum Lesen von Slice- und Kartendaten verwendet werden :
for k,v:=range map {
fmt.Println("map's key:",k)
fmt.Println("map's val:",v)
}
Da Go „Mehrere Wertrückgaben“ unterstützt, meldet der Compiler einen Fehler für Variablen, die „deklariert, aber nicht aufgerufen“ werden. In diesem Fall können Sie _ verwenden, um die unnötigen Rückgabewerte zu verwerfen . Beispielsweise
for _, v := range map{
fmt.Println("map's val:", v)
}
schalten
Manchmal müssen Sie viele If-Else-Anweisungen schreiben, um eine logische Verarbeitung zu implementieren. Zu diesem Zeitpunkt sieht der Code hässlich und langwierig aus und ist in Zukunft nicht einfach zu warten. Zu diesem Zeitpunkt kann Switch dieses Problem sehr gut lösen . Seine Syntax ist wie folgt
switch sExpr {
case expr1:
some instructions
case expr2:
some other instructions
case expr3:
some other instructions
default:
other code
}
Die Typen von sExpr und expr1, expr2, expr3 müssen konsistent sein. Der Schalter von Go ist sehr flexibel. Der Ausdruck muss keine Konstante oder Ganzzahl sein. Der Ausführungsprozess erfolgt von oben nach unten, bis eine Übereinstimmung gefunden wird. Wenn der Schalter keinen Ausdruck hat, stimmt er mit true überein.
i := 10
switch i {
case 1:
fmt.Println("i is equal to 1")
case 2, 3, 4:
fmt.Println("i is equal to 2, 3 or 4")
case 10:
fmt.Println("i is equal to 10")
default:
fmt.Println("All I know is that i is an integer")
}
In Zeile 5 aggregieren wir viele Werte zu einem Fall. Gleichzeitig entspricht der Wechsel in Go einer Pause am Ende jedes Falles . Nach einem erfolgreichen Match werden andere Fälle nicht automatisch nach unten ausgeführt, sondern Der gesamte Schalter wird übersprungen. Sie können Fallthrough jedoch verwenden, um die Ausführung des nachfolgenden Fallcodes zu erzwingen .
integer := 6
switch integer {
case 4:
fmt.Println("The integer was <= 4")
fallthrough
case 5:
fmt.Println("The integer was <= 5")
fallthrough
case 6:
fmt.Println("The integer was <= 6")
fallthrough
case 7:
fmt.Println("The integer was <= 7")
fallthrough
case 8:
fmt.Println("The integer was <= 8")
fallthrough
default:
fmt.Println("default case")
}
// 上面的程序将输出
The integer was <= 6
The integer was <= 7
The integer was <= 8
default case