Explication détaillée de l'utilisation de l'instruction switch et de l'instruction select dans Golang

Cet article vous présente principalement le didacticiel d'utilisation de switch et select dans Golang. L'article présente l'utilisation de instruction switch et de l'instruction select de manière très détaillée à travers un exemple de code, ce qui est d'une certaine importance pour tout le monde. . En référence à la valeur de l'apprentissage, les amis dans le besoin peuvent suivre l'éditeur pour apprendre ensemble.

Cet article vous présente principalement le contenu pertinent sur l'utilisation de switch et select dans Golang. Il est partagé pour votre référence et votre apprentissage. Jetons un coup d'œil à l'introduction détaillée :

<.>1. Instruction Switch

L'instruction switch fournit une méthode d'exécution conditionnelle multibranche. Chaque cas peut porter une

expression ou un spécificateur de type. La première peut également être appelée expression de cas. Par conséquent, l’instruction switch dans le langage Go est divisée en instruction switch d’expression et instruction switch de type.

1. Instruction de changement d'expression

var name string 
... 
switch name { 
case "Golang": 
 fmt.Println("Golang") 
case "Rust": 
 fmt.Println("Rust") 
default: 
 fmt.Println("PHP是世界上最好的语言") 
}

Go changera chaque élément dans l'ordre de haut en bas. L'expression case dans une instruction case est évaluée. Tant que l'expression a le même résultat que l'expression switch, l'instruction case sera sélectionnée. Le reste des déclarations de cas sera ignoré. Comme si, l'instruction switch peut également contenir des mots d'initialisation, et leur apparence et leur écriture sont exactement les mêmes :

names := []string{"Golang","java","PHP"} 
switch name:=names[0];name { 
case "Golang": 
 fmt.Println("Golang") 
... 
default: 
 fmt.Println("Unknown") 
}

2. Tapez l'instruction switch
et la forme générale. Le premier point est que ce qui suit le mot-clé case n’est pas une expression, mais un spécificateur de type. Un spécificateur de type se compose de plusieurs littéraux de type, et plusieurs littéraux de type sont séparés par des virgules. Le deuxième point est que son expression switch est très particulière. Cette expression spéciale joue également le rôle d'assertion de type, mais son expression est très particulière, comme par exemple :

, où v doit représenter une valeur de type

interface v.(type). Ce type d'expression ne peut apparaître que dans les instructions switch de type et ne peut servir que d'expressions switch. Un exemple d'instruction de type switch est le suivant :

Ici, nous attribuons le résultat de l'expression switch à une variable. De cette façon, nous pouvons utiliser ce résultat dans l’instruction switch. Une fois ce code exécuté, le résultat est : "

v := 11 
switch i := interface{}(v).(type) { 
case int, int8, int16, int32, int64: 
 fmt.Println("A signed integer:%d. The type is %T. \n", v, i) 
case uint, uint8, uint16, uint32, uint64: 
 fmt.Println("A unsigned integer: %d. The type is %T. \n", v, i) 
default: 
 fmt.Println("Unknown!") 
}

"

A signed integer:11. The type is int.
Enfin, parlons de la chute. C'est à la fois un mot-clé et peut représenter une déclaration. Une instruction de remplacement peut être incluse dans une instruction case au sein d'une instruction switch d'expression. Sa fonction est de transférer le contrôle au cas suivant. Cependant, veuillez noter que l'instruction fallthrough ne peut apparaître que comme dernière instruction dans l'instruction case. De plus, l'instruction case qui la contient n'est pas la dernière instruction case de l'instruction switch à laquelle elle appartient.

2. Instruction Select
La fonction de sélection de Golang est similaire à Select, Poll et epoll, qui est de surveiller le fonctionnement IO, lorsqu'une opération IO se produit, l'action correspondante est déclenchée.

Exemple :

Remarquez que la forme de code de select est très similaire à celle de switch, mais les instructions d'opération dans le le cas de sélection ne peut que C'est [Opération IO].

ch1 := make (chan int, 1) 
ch2 := make (chan int, 1) 
 
... 
 
select { 
case <-ch1: 
 fmt.Println("ch1 pop one element") 
case <-ch2: 
 fmt.Println("ch2 pop one element") 
}

Dans cet exemple, select attendra qu'une certaine instruction case soit terminée, c'est-à-dire jusqu'à ce que les données soient lues avec succès à partir de ch1 ou ch2. L'instruction select se termine.

L'instruction break peut également être incluse dans l'instruction case dans l'instruction select. Sa fonction est de mettre immédiatement fin à l'exécution de l'instruction select en cours. Indépendamment du fait qu'il existe ou non des instructions non exécutées dans l'instruction case à laquelle elle appartient.

[Utilisez select pour implémenter le mécanisme de délai d'attente]

comme suit :

Lorsque le délai d'attente le temps est écoulé, le cas 2 fonctionnera avec succès. Ainsi, l'instruction select va

timeout := make(chan bool, 1) 
go func() { 
 time.Sleep(time.Second * 10) 
 timeout <- true 
}() 
select { 
case <-pssScanResponseChan: 
 
case <-timeout: 
 fmt.PrintIn("timeout!") 
}

sortir

. Au lieu de toujours bloquer sur l'opération de lecture du ch. Ceci implémente le paramètre de délai d'attente pour les opérations de lecture ch.
Le suivant est plus intéressant.

Lorsque l'instruction select contient default :

À ce stade, parce que ch1 et ch2 sont tous deux vides, case1 et case2 non plus sera lu avec succès. Ensuite, select exécute l'instruction par défaut.

ch1 := make (chan int, 1) 
ch2 := make (chan int, 1) 
 
select { 
case <-ch1: 
 fmt.Println("ch1 pop one element") 
case <-ch2: 
 fmt.Println("ch2 pop one element") 
default: 
 fmt.Println("default") 
}

Grâce à cette fonctionnalité par défaut, nous pouvons utiliser l'instruction select pour détecter si le chan est plein.

est le suivant :

Parce que ch est déjà pleine lors de l'insertion de 1. Lorsque ch est sur le point d'insérer 2, c'est trouvé que ch est déjà plein (le cas 1 est bloqué), puis select exécute l'instruction par défaut. De cette façon, il est possible de détecter si le canal est plein au lieu d'attendre tout le temps.

ch := make (chan int, 1) 
ch <- 1 
select { 
case ch <- 2: 
default: 
 fmt.Println("channel is full !") 
}

Par exemple, si nous avons un service, lorsqu'une demande arrive, nous générerons un travail et le lancerons dans le canal, et d'autres coroutines récupéreront le travail du canal pour exécution. Mais nous espérons que lorsque la chaîne sera masquée, nous abandonnerons le travail et répondrons [Le service est occupé, veuillez réessayer plus tard. ] Vous pouvez utiliser select pour répondre à cette exigence.

此外，利用default特性，我们可以使用select语句将chan清空，如下：

flag := false 
for { 
 select { 
 case <-pssScanResponseChan: 
 continue 
 default: 
 flag = true 
 } 
 if true == flag { 
 break 
 } 
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!