Die Steuerungssyntax von Go ist sehr einfach gestaltet und kann mit einem Minimum an reservierten Wörtern geschrieben werden. Daher gibt es viele Variationen in der Beschreibungsmethode, daher werde ich sie zusammenfassen.
Die erste ist die ** if-Anweisung **, die die bedingte Verzweigung steuert. Die Grundform der if-Anweisung lautet wie folgt.
wenn bedingter Ausdruck{
Verarbeitung, wenn Bedingungen erfüllt sind
}sonst wenn bedingter Ausdruck{
Verarbeitung, wenn der erste bedingte Ausdruck nicht erfüllt ist
} else {
Verarbeitung, wenn nicht alle bedingten Ausdrücke erfüllt sind
}
Der bedingte Ausdruck muss übrigens ein Bool-Wert sein.
Sie können eine einfache Anweisung festlegen, indem Sie den bedingten Ausdruck durch ein Semikolon trennen.
x, y := 5, 10
if a := x * y; a == 50 {
fmt.Println("Variable a ist 50")
} else {
fmt.Println("Variable a ist ein Rätsel")
} //Variable a ist 50
Sie können auch die if-Anweisung verwenden, um Fehler zu behandeln.
import (
"os"
"log"
)
func test() error {
_, e := os.Open("test.txt")
return e
}
func main() {
if err := test(); err != nil {
log.Fatal(err) //test.Da die Datei mit dem Namen txt nicht vorhanden ist, wird eine Fehlermeldung ausgegeben.
}
}
Wie ich im vorherigen Artikel (About Go-Funktionen) [https://qiita.com/noa-1129/items/589d514b4eda0cf9c632 "Qiita") geschrieben habe, habe ich diesmal die Funktionen in zwei Teile geteilt und den Fehler behandelt. Ich mache es. Einfach ausgedrückt, definiert es eine Funktion, die die Fehlerschnittstelle als Rückgabewert verwendet und die fiktive Datei "test.txt" im Betriebssystempaket öffnet. Die Funktion wird von der Hauptfunktion empfangen und der Fehler ermittelt.
In Go ist die einzige Syntax zur Beschreibung von Schleifen für. Das Folgende ist ein nackter, für den nicht angegeben ist. For for führt eine Endlosschleife aus, wenn nichts angegeben ist.
for {
fmt.Println("Nackt für") //Endlosschleife
}
Sie können eine typische for-Anweisung schreiben, die Sie häufig sehen, indem Sie die Initialisierungsanweisung, den bedingten Ausdruck und die Nachbearbeitung anordnen, indem Sie sie durch ein Semikolon trennen.
for a := 0; a < 10; a++ {
fmt.Println(a) //0 1 2 3 4 5 6 7 8 9
}
Eine for-Anweisung, die einen Bereichsausdruck unter Verwendung des ** reservierten Wortbereichs ** definiert.
tests := [3]string{ "test1", "test2", "test3" }
for i, a := range tests {
fmt.Printf("[%d]%s\n", i, a) //[0]test1
//[1]test2
//[2]test3
}
In diesem Programm wird der Index des Arrays i zugewiesen und der Wert der Variablentests wird der Variablen a zugewiesen, und das Array und der Index werden wiederholt wiederholt.
Es ist auch möglich, über einen Zeichenfolgentyp mithilfe des Bereichs zu iterieren. Da der iterative Wert jedoch ** Rattentyp ** wird, wird er in Unicode als Zeichencode ausgegeben. Darüber hinaus wird der Index der Zeichenfolge für jeden UTF-8-codierten Codepunkt wiederholt, sodass der Betrag des Indexinkrements abhängig vom Codepunkt des Zeichens variiert.
Die switch-Anweisung ist ein Prozess, bei dem eine einfache Anweisung willkürlich platziert, der Ausdruck ausgewertet und eine Verzweigungsverarbeitung durchgeführt wird. Darüber hinaus verfügt die switch-Anweisung über zwei Prozesse: eine switch-Anweisung mit einem ** Ausdruck ** und eine switch-Anweisung mit einem ** Typ **.
einfache Anweisung wechseln(;)Formel{
Jeder Verzweigungsprozess...
}
Unten finden Sie eine switch-Anweisung, die einen Ausdruck verwendet.
switch a := 2; a {
case 1:
fmt.Println("Ist 1")
case 2:
fmt.Println("2") //Ausgabe
case 3:
fmt.Println("3")
case 4:
fmt.Println("4")
case 5:
fmt.Println("5")
default:
fmt.Println("Geheimnisvoller Wert")
Der Ausdruck, in dem 2 der Variablen a zugeordnet ist, wird ausgewertet und eine Verzweigungsverarbeitung durchgeführt.
Es ist auch möglich, einen Ausdruck in dem Fall festzulegen und eine Verzweigungsverarbeitung durchzuführen.
b, c := 1, 5
switch a := 5; a {
case b + c:
fmt.Println("Zusatz")
case b - c:
fmt.Println("Subtraktion")
case b * c:
fmt.Println("Multiplizieren") //Ausgabe
case b / c:
fmt.Println("Teilen")
5 wird der Variablen a zugeordnet, und die Verzweigungsverarbeitung wird jeweils aus dem jeweils eingestellten Ausdruck durchgeführt.
Sie können eine switch-Anweisung einfach mit einem Typ schreiben, indem Sie eine Verzweigungsverarbeitung in Kombination mit einer Typzusicherung durchführen.
var x interface{} = 5
switch a := x.(type) { //Geben Sie die Bestätigungsformel ein
case int:
fmt.Println(a * a) //Ausgabe//25
case bool:
fmt.Println("Bool-Typ")
case string:
fmt.Println("Zeichenfolgentyp")
default:
fmt.Println("Geheimnisvoller Wert")
}
Dieses Programm definiert eine Variable mit dem Typ interface {}, die mit allen Typen kompatibel ist, und verzweigt den Wert aus einem Ausdruck, der eine Funktion namens ** type assertion ** verwendet, die den Typ dynamisch überprüft. Ich mache es.
** break-Anweisung ** als Funktion zum Unterbrechen der Schleifenverarbeitung Es gibt eine ** continue-Anweisung ** als Funktion, um die verbleibende Verarbeitung zu überspringen und mit der nächsten Schleifenverarbeitung fortzufahren.
break.go
a := 0
for {
fmt.Println(a)
a++
if a == 10 {
break //Die Verarbeitung wird unterbrochen, wenn die Variable a 10 wird.
}
}
continue.go
for a := 0; a < 10; a++ {
if a == 5 {
continue
}
fmt.Println(a) //Wenn die Variable a 5 wird, überspringen Sie ihren Wert
}
Durch Kombinieren von Beschriftungen mit break- und continue-Anweisungen können Sie zu jeder Position springen, auch wenn mehrere Nester vorhanden sind. ** Label: Definiert die Position in Form von **.
break.go
a := 5
EXIT:
for {
for {
for {
fmt.Println(a * a) //25
break EXIT
}
fmt.Println(a + a) //Nicht ausgegeben
}
fmt.Println(a - a) //Nicht ausgegeben
}
fmt.Println("DONE") //DONE
Ich habe das Label EXIT definiert und bin bei break EXIT davongekommen.
Als nächstes wird die continue-Anweisung verwendet.
continue.go
SKIP:
for a := 1; a <= 5; a++ {
for b := 1; b <= 5; b++ {
if b > 1 {
continue SKIP
}
fmt.Printf("a = %d, b = %d\n", a, b) //a = 1, b = 1
} //a = 2, b = 1
fmt.Println("Komm nicht her") //a = 3, b = 1
} //a = 4, b = 1
//a = 5, b = 1
Das for ist doppelt verschachtelt und die Schleife wird übersprungen, wenn b für das innere for mehr als 1 ist. Mit anderen Worten, Sie können sehen, dass die innere Schleife nur einmal ausgeführt wurde.
** defer ** kann einen Ausdruck registrieren, der ausgeführt wird, wenn die Funktion endet.
func main() {
defer fmt.Println("defer1")
defer fmt.Println("defer2")
fmt.Println("Dies ist zuerst") //Dies ist zuerst
} //defer2
//defer1
Als Einschränkung gibt es einen Punkt, an dem es aus der später registrierten Formel ausgegeben wird.
Sie können auch mehrere Verzögerungen mithilfe einer anonymen Funktion registrieren.
defer func() {
fmt.Println("defer1")
fmt.Println("defer2")
fmt.Println("defer3")
}()
Als nächstes kann die Datei auch mit defer geschlossen werden, um Verarbeitungsauslassungen beim Öffnen der Datei zu vermeiden.
Prozess zum Öffnen von Dateien...
}
defer file.Close()
Mit der Anweisung go können Sie eine ** Goroutine ** generieren, die parallel verarbeitet wird.
func test() {
tests := [...]string{ "test1", "test2", "test3" }
for i, a := range tests {
fmt.Printf("[%d]%s\n", i, a)
}
}
func main() {
go test()
mains := [3]string{ "main1", "main2", "main3" }
for i, b := range mains {
fmt.Printf("[%d]%s\n", i, b)
}
}
Ausführungsergebnis
[0]main1
[1]main2
[2]main3
[0]test1
[1]test2
[2]test3
Durch Setzen von go test () `in der Hauptfunktion wird die Goroutine der Testfunktion generiert und die Parallelverarbeitung unregelmäßig durchgeführt. Übrigens, wenn Sie den Array-Typ gleich machen, funktioniert er nicht gut, seien Sie also vorsichtig.
Dies funktioniert auch bei anonymen Funktionen.
Dieses Mal habe ich die Steuerungssyntax zusammengefasst! Ich denke, die Steuerungssyntax ist ein häufiger Prozess, deshalb möchte ich sie gut verstehen ~
Recommended Posts