Golang-Prozesssteuerung

Golang ist eine effiziente und moderne Programmiersprache, die umfangreiche Funktionen zur Prozesssteuerung bietet. In diesem Artikel werden die Flusskontrollstrukturen in Golang untersucht, einschließlich bedingter Anweisungen, Schleifenanweisungen und Sprunganweisungen, um den Lesern zu helfen, diese Strukturen besser zu verstehen und anzuwenden.

Bedingte Anweisungen

Bedingte Anweisungen in Golang umfassen if-Anweisungen, switch-Anweisungen und select-Anweisungen.

1. if-Anweisung

if-Anweisung wird verwendet, um bedingte Urteile zu fällen. Die Syntax lautet wie folgt:

if condition {
    statement(s)
} else if condition {
    statement(s)
} else {
    statement(s)
}

wobei Bedingung ein bedingter Ausdruck ist, der zur Beurteilung von wahr oder falsch verwendet wird. Wenn die Bedingung erfüllt ist, wird der folgende Anweisungsblock ausgeführt, andernfalls wird der Anweisungsblock übersprungen und die nächste Anweisung ausgeführt.

Wenn auf die Bedingung das Schlüsselwort else if folgt, wird jeder bedingte Ausdruck der Reihe nach ausgewertet und der erste Anweisungsblock, der wahr ist, wird ausgeführt. Wenn alle bedingten Ausdrücke falsch sind, wird der auf else folgende Anweisungsblock ausgeführt. Ohne den else-Block wird keine Anweisung ausgeführt, wenn die Bedingung falsch ist.

Das Folgende ist ein Beispiel für eine if-Anweisung:

package main

import "fmt"

func main() {
    var a int = 10
    if a < 20 {
        fmt.Printf("a 小于 20
")
    }
    fmt.Printf("a 的值为 : %d
", a)
}

Ausgabeergebnis:

a 小于 20
a 的值为 : 10

2. switch-Anweisung

switch-Anweisung wird für die Beurteilung mehrerer Bedingungen verwendet. Die Syntax lautet wie folgt:

switch expression {
    case value1:
        statement(s)
    case value2:
        statement(s)
    case value3:
        statement(s)
    default:
        statement(s)
}

Wo ist der Ausdruck? ein Ausdruck, der zum Abgleichen einer Konstante oder Variablen in einer Case-Klausel verwendet wird. Wenn die Übereinstimmung erfolgreich ist, wird der entsprechende Anweisungsblock ausgeführt. Andernfalls wird der Anweisungsblock übersprungen und die nächste Case-Klausel (falls vorhanden) ausgeführt.

Wenn nicht alle Case-Klauseln erfolgreich abgeglichen werden, wird der Anweisungsblock nach der Standardeinstellung ausgeführt. Wenn keine Standardklausel vorhanden ist, werden keine Anweisungen ausgeführt.

Das Folgende ist ein Beispiel für eine Switch-Anweisung:

package main

import "fmt"

func main() {
    var grade string = "B"
    var marks int = 90

    switch marks {
        case 90:
            grade = "A"
        case 80:
            grade = "B"
        case 60, 70:
            grade = "C"
        default:
            grade = "D"
    }

    switch {
        case grade == "A" :
            fmt.Printf("优秀!
" )
        case grade == "B", grade == "C" :
            fmt.Printf("良好
" )
        case grade == "D" :
            fmt.Printf("及格
" )
        case grade == "F":
            fmt.Printf("不及格
" )
        default:
            fmt.Printf("差
" )
    }
    fmt.Printf("你的等级是 %s
", grade )
}

Ausgabeergebnis:

良好!
你的等级是 B

3. select-Anweisung

select-Anweisung wird verwendet, um mehrere Kanäle gleichzeitig zu überwachen:

select {
    case communication clause 1:
        statement(s)
    case communication clause 2:
        statement(s)
    .............
    default:
        statement(s)
}

Among In ihnen bezieht sich die Kommunikationsklausel auf einen Kanal oder eine Kanaloperation mit Richtung, einschließlich Sendeoperation und Empfangsoperation. Wenn ein Kanal Daten hat, die gelesen oder geschrieben werden können, wird der entsprechende Anweisungsblock ausgeführt; andernfalls wird der Kanal übersprungen und die nächste Kommunikationsklausel ausgeführt. Wenn auf keinem Kanal Daten lesbar oder beschreibbar sind, wird der dem Standard folgende Anweisungsblock ausgeführt.

Das Folgende ist ein Beispiel für eine Select-Anweisung:

package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

Ausgabeergebnis:

0
1
1
2
3
5
8
13
21
34
quit

Loop-Anweisung

Loop-Anweisungen in Golang umfassen for-Anweisungen und Range-Anweisungen.

1. for-Anweisung

for-Anweisung wird verwendet, um einen Codeabschnitt in einer Schleife auszuführen. Die Syntax lautet wie folgt:

for init; condition; post {
    statement(s);
}

Dabei wird init zum Starten der Schleife verwendet, und die Bedingung wird verwendet, um zu bestimmen, ob die Schleife ausgeführt wird wird fortgesetzt und Post wird verwendet, um den Betrieb von Schleifenvariablen zu steuern.

Das Folgende ist ein Beispiel für eine for-Anweisung:

package main

import "fmt"

func main() {
    var b int = 15
    var a int

    for i := 0; i < 10; i++ {
        fmt.Printf("i 的值为: %d
", i)
    }

    for a < b {
        a++
        fmt.Printf("a 的值为: %d
", a)
    }
}

Ausgabeergebnis:

i 的值为: 0
i 的值为: 1
i 的值为: 2
i 的值为: 3
i 的值为: 4
i 的值为: 5
i 的值为: 6
i 的值为: 7
i 的值为: 8
i 的值为: 9
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 10
a 的值为: 11
a 的值为: 12
a 的值为: 13
a 的值为: 14
a 的值为: 15

2. range-Anweisung

Die range-Anweisung wird verwendet, um über die Elemente eines Arrays, Slice, Kanals oder einer Karte zu iterieren. Die Syntax ist wie folgt:

for key, value := range oldMap {
    newMap[key] = value
}

wobei „key“ und „value“ den Schlüssel bzw. den Wert des aktuellen Elements darstellen.

Das Folgende ist ein Beispiel für eine Bereichsanweisung:

package main

import "fmt"

func main() {
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s
", k, v)
    }
}

Ausgabeergebnis:

sum: 9
index: 1
a -> apple
b -> banana

Jump-Anweisung

Jump-Anweisungen in Golang umfassen break, continue und goto.

1. break-Anweisung

break-Anweisung wird verwendet, um den Schleifenkörper zu unterbrechen. Die Syntax lautet wie folgt:

for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
    fmt.Printf("%d ", i)
}
fmt.Println()

Ausgabeergebnis:

0 1 2 3 4

2. continue-Anweisung

continue-Anweisung wird verwendet, um diese Iteration des Stroms zu unterbrechen Schleifenkörper, die Syntax lautet wie folgt:

for i := 0; i < 10; i++ {
    if i == 5 {
        continue
    }
    fmt.Printf("%d ", i)
}
fmt.Println()

Ausgabeergebnis:

0 1 2 3 4 6 7 8 9

3. goto-Anweisung

goto-Anweisung wird verwendet, um zur Ausführung bedingungslos zu einem bestimmten Codelabel (Label) zu springen

wobei label ein Bezeichner und Anweisung eine Ausführungsanweisung ist.

Das Folgende ist ein Beispiel für eine goto-Anweisung:

goto label;
...
label: statement

Ausgabeergebnis:

package main

import "fmt"

func main() {
    i := 0
Again:
    fmt.Printf("循环执行次数：%d
", i)
    i++
    if i < 10 {
        goto Again
    }
}

Zusammenfassung

Flusskontrollstrukturen in Golang umfassen bedingte Anweisungen, Schleifenanweisungen und Sprunganweisungen. Zu den bedingten Anweisungen gehören if-, switch- und select-Anweisungen, die zur Beurteilung einzelner oder mehrerer Bedingungen verwendet werden. Zu den Schleifenanweisungen gehören for- und range-Anweisungen, die zum Durchlaufen eines Codeabschnitts oder zum Durchlaufen eines Elements verwendet werden. Zu den Sprunganweisungen gehören Break-, Continue- und Goto-Anweisungen, die zum Unterbrechen der aktuellen Schleife oder zum bedingungslosen Springen zu einer Marke zur Ausführung verwendet werden. Bei der tatsächlichen Programmierung ist es erforderlich, die geeignete Prozesssteuerungsstruktur entsprechend den Anforderungen zur Implementierung der Codelogik flexibel auszuwählen.

Das obige ist der detaillierte Inhalt vonGolang-Prozesssteuerung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!