La syntaxe de contrôle de Go est conçue pour être très simple et peut être écrite avec un minimum de mots réservés. Par conséquent, il existe de nombreuses variantes dans la méthode de description, je vais donc les résumer.
Le premier est l'instruction ** if ** qui contrôle le branchement conditionnel. La forme de base de l'instruction if est la suivante.
si expression conditionnelle{
Traitement lorsque les conditions sont remplies
}else si expression conditionnelle{
Traitement lorsque la première expression conditionnelle n'est pas satisfaite
} else {
Traitement lorsque toutes les expressions conditionnelles ne sont pas satisfaites
}
À propos, l'expression conditionnelle doit être une valeur booléenne.
Vous pouvez définir une instruction simple en séparant l'expression conditionnelle par un point-virgule.
x, y := 5, 10
if a := x * y; a == 50 {
fmt.Println("La variable a est 50")
} else {
fmt.Println("La variable a est un mystère")
} //La variable a est 50
Vous pouvez également utiliser l'instruction if pour gérer les erreurs.
import (
"os"
"log"
)
func test() error {
_, e := os.Open("test.txt")
return e
}
func main() {
if err := test(); err != nil {
log.Fatal(err) //test.Comme le fichier appelé txt n'existe pas, un message d'erreur est émis.
}
}
Comme je l'ai écrit dans l'article précédent (À propos des fonctions Go) [https://qiita.com/noa-1129/items/589d514b4eda0cf9c632 "Qiita"), cette fois j'ai divisé les fonctions en deux et j'ai géré l'erreur. Je le fais. En termes simples, il définit une fonction qui prend l'interface d'erreur comme valeur de retour et ouvre le fichier fictif "test.txt" dans le package os. La fonction est reçue par la fonction principale et l'erreur est déterminée.
Dans Go, la seule syntaxe pour décrire les boucles est pour. Ce qui suit est un nu pour qui n'est pas spécifié. For for exécute une boucle infinie si rien n'est spécifié.
for {
fmt.Println("Nu pour") //boucle infinie
}
Vous pouvez écrire une instruction for typique que vous voyez souvent en organisant l'instruction d'initialisation, l'expression conditionnelle et le post-traitement en les séparant par un point-virgule.
for a := 0; a < 10; a++ {
fmt.Println(a) //0 1 2 3 4 5 6 7 8 9
}
Une instruction for qui définit une expression de plage à l'aide de la ** plage de mots réservés **.
tests := [3]string{ "test1", "test2", "test3" }
for i, a := range tests {
fmt.Printf("[%d]%s\n", i, a) //[0]test1
//[1]test2
//[2]test3
}
Dans ce programme, l'indice du tableau est assigné à i et la valeur de la variable tests est assignée à la variable a, et le tableau et l'index sont mis en boucle à plusieurs reprises.
Il est également possible d'itérer sur un type de chaîne en utilisant range, mais comme la valeur itérative devient ** type rune **, elle est sortie sous forme de code de caractère en Unicode. De plus, l'index de la chaîne est répété pour chaque point de code codé UTF-8, de sorte que la quantité d'incrément d'index varie en fonction du point de code du caractère.
L'instruction switch est un processus dans lequel une instruction simple est placée arbitrairement, l'expression est évaluée et un traitement de branche est effectué. En outre, l'instruction switch comporte deux processus: une instruction switch avec une ** expression ** et une instruction switch avec un ** type **.
switch simple instruction(;)formule{
Chaque processus de branche...
}
Vous trouverez ci-dessous une instruction switch utilisant une expression.
switch a := 2; a {
case 1:
fmt.Println("Est 1")
case 2:
fmt.Println("2") //production
case 3:
fmt.Println("3")
case 4:
fmt.Println("4")
case 5:
fmt.Println("5")
default:
fmt.Println("Valeur mystérieuse")
L'expression dans laquelle 2 est affecté à la variable a est évaluée et un traitement de branche est effectué.
Il est également possible de définir une expression dans le cas et d'effectuer un traitement de branche.
b, c := 1, 5
switch a := 5; a {
case b + c:
fmt.Println("une addition")
case b - c:
fmt.Println("soustraction")
case b * c:
fmt.Println("Multiplier") //production
case b / c:
fmt.Println("Diviser")
5 est affecté à la variable a, et le traitement de branche est effectué à partir de l'ensemble d'expressions dans chaque cas.
Vous pouvez facilement écrire une instruction switch à l'aide d'un type en effectuant un traitement de branche en combinaison avec une assertion de type.
var x interface{} = 5
switch a := x.(type) { //Formule d'assertion de type
case int:
fmt.Println(a * a) //production//25
case bool:
fmt.Println("type booléen")
case string:
fmt.Println("type de chaîne")
default:
fmt.Println("Valeur mystérieuse")
}
Ce programme définit une variable de type interface {} compatible avec tous les types et branche la valeur à partir d'une expression qui utilise une fonction appelée ** assertion de type ** qui vérifie dynamiquement le type. Je le fais.
** instruction break ** comme fonction pour interrompre le traitement de la boucle Il existe une ** instruction continue ** en tant que fonction pour ignorer le traitement restant et passer au traitement en boucle suivant.
break.go
a := 0
for {
fmt.Println(a)
a++
if a == 10 {
break //Le traitement est interrompu lorsque la variable a devient 10.
}
}
continue.go
for a := 0; a < 10; a++ {
if a == 5 {
continue
}
fmt.Println(a) //Lorsque la variable a devient 5, ignorez sa valeur
}
En combinant des étiquettes avec des instructions break et continue, vous pouvez accéder à n'importe quelle position même s'il existe plusieurs nids. ** Libellé: définit la position sous la forme de **.
break.go
a := 5
EXIT:
for {
for {
for {
fmt.Println(a * a) //25
break EXIT
}
fmt.Println(a + a) //Pas de sortie
}
fmt.Println(a - a) //Pas de sortie
}
fmt.Println("DONE") //DONE
J'ai défini le label EXIT et je me suis échappé à la pause EXIT.
Vient ensuite le cas de l'utilisation de l'instruction continue.
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("Ne viens pas ici") //a = 3, b = 1
} //a = 4, b = 1
//a = 5, b = 1
Le for est double imbriqué et la boucle est ignorée lorsque b est supérieur à 1 pour le for intérieur. En d'autres termes, vous pouvez voir que la boucle interne n'a été exécutée qu'une seule fois.
** defer ** peut enregistrer une expression qui sera exécutée à la fin de la fonction.
func main() {
defer fmt.Println("defer1")
defer fmt.Println("defer2")
fmt.Println("C'est le premier") //C'est le premier
} //defer2
//defer1
En guise de mise en garde, il y a un point qu'il est sorti de la formule enregistrée plus tard.
Vous pouvez également enregistrer plusieurs reports en utilisant une fonction anonyme.
defer func() {
fmt.Println("defer1")
fmt.Println("defer2")
fmt.Println("defer3")
}()
Ensuite, différer peut également être utilisé pour fermer le fichier afin d'éviter les omissions de traitement lors de l'ouverture du fichier.
Processus d'ouverture de fichier...
}
defer file.Close()
Vous pouvez utiliser l'instruction go pour générer une ** goroutine ** qui est traitée en parallèle.
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)
}
}
Résultat d'exécution
[0]main1
[1]main2
[2]main3
[0]test1
[1]test2
[2]test3
En définissant `` go test () '' dans la fonction principale, la goroutine de la fonction de test est générée et le traitement parallèle est effectué de manière irrégulière. Au fait, si vous faites le même type de tableau, cela ne fonctionnera pas bien, alors soyez prudent.
Cela fonctionne également de la même manière lors de l'utilisation de fonctions anonymes.
Cette fois, j'ai résumé la syntaxe du contrôle! Je pense que la syntaxe de contrôle est un processus fréquent, donc je veux bien la comprendre ~
Recommended Posts