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

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是世界上最好的语言") 
}

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

2. Tapez l'instruction switch < Il existe deux différences entre l'instruction switch de type 🎜>
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 :

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 :

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 :

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 :

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

. 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 :

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 :

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!