Pour continuer avec les structures de contrôle, voyons une forme particulière de l'instruction switch : son utilisation sans variable (tagless). Il s'agit d'une variante de switch - case.

Dans l'utilisation de switch vue précédemment, on avait une variable (désignée tag ou étiquette), par exemple x. C'est la valeur de cette variable x qui va être comparée aux constantes définies dans chaque case.

Vous pouvez également utiliser switch sans variable (tagless). Dans ce cas,le premier case dont l'expression est vraie est exécuté. Au lieu d'avoir une constante après le case, il y aura une expression booléenne et si ce booléen est vrai, alors le bloc correspondant au case sera exécuté.

Ci-dessous voici un exemple :

switch{
case x > 1:
   fmt.Printf("case 1")
case x < -1:
   fmt.Printf("case 2")
default:
   fmt.Printf("no case")
}

Dans ce cas, le switch n'est pas suivi d'une étiquette ou variable (tagless). Nous avons définit deux case et une valeur par défaut. Le cas ou x est supérieur à 1, le cas ou x est inférieur à -1, et enfin tout autre cas (default). Ici puisqu'il n'y a pas de variable après switch, on évalue simplement les conditions à droite du mot-clé case. Si c'est vrai, alors on exécute les instructions du bloc associé au case. Si c'est faux, on évalue le case suivant pour voir si sa condition est vraie, et ainsi de suite jusqu'à avoir passé tous les case. Si aucune condition ne s'est révélée vraie, on exécute les instruction du bloc default.

On peut utiliser cette forme à la place des enchaînements moins lisibles if…else if…else if..else.

break et continue sont également des instructions de contrôle. Parfois considérés comme une forme à éviter car leur utilisation intensive peut rendre la maintenance du code plus complexe ils existent bel et bien et sont parfois nécessaires.

Utilisation au sein des boucles :

i := 0
for i < 10 {
   i++
   if i == 5 { break }
   fmt.Printf("hi ")
}

L'instruction break quitte la boucle contenante. Dans l'exemple la boucle for sera interrompue lorsque i vaudra 5. break saute simplement hors de la boucle contenante et quitte la boucle.

L'instruction continue s'utilise également dans les boucles. Cela n’interrompt pas la boucle contenant, cela ignore simplement l'itération en cours de la boucle.

i := 0
for i < 10 {
   i++
   if i == 5 { continue }
   fmt.Printf("hi ")
}

Ci-dessus, le continue remplace le break de l'exemple précédent. Lorsque i vaut 5, l'instruction continue est exécutée. Les instructions suivantes de la boucle ne sont pas exécutées (ici l'affichage du message) et l'itération suivante commence directement. La boucle s'exécutera donc, mais elle ne s'exécutera pas complètement ses instructions sur les 10 itérations car lors de la 5ième itération le message ne sera pas affiché : cela ignorera une itération de la boucle.

Scan est une fonction permettant de lire la saisie de l'utilisateur. Il ne s'agit pas d'une fonction agissant sur le contrôle du flot d'instruction mais nous l'abordons ici car la lecture des entrées utilisateur est quelque chose que vous rencontrerez rapidement autant dans les exemples que dans vos essais de code.

Régulièrement vous aurez à lire les entrées que l'utilisateur saisit sur le clavier.Scan est définie dans le paquet fmt, elle prend en argument un pointeur vers une valeur que vous vous attendez à ce que l'utilisateur saisisse.

Ainsi, si un utilisateur doit renseigner/saisir un entier, vous devez créer un entier et transmettre un pointeur vers cet entier à la fonction scan().

Vous appelez Scan, et lorsque la fonction s'exécute, elle attend la saisie. Le programme attend que l'utilisateur saisisse quelque chose et appuie sur ↵ Entrée. Lorsqu'ils appuient sur ↵ Entrée, la fonction scan prend tout ce qu'il a saisi et met à jour le ou les pointeurs passés en argument.

Si vous passez un pointeur sur un entier, scan transformera la saisie en un entier, et mettra à jour le pointeur passé en argument avec l'adresse de cet entier.

La valeur retournée par la fonction Scancorrespond au nombre d'éléments lus. Elle renvoie en fait deux choses :

• Le nombre d'éléments lus (séparés par des caractères d'espacement ou des retour à la ligne).
• un code d'erreur. S'il y a une erreur, elle renverra autre chose que zéro : ce code d'erreur pourra être analysé.

apples.go

package main
 
import "fmt"
 
var appleNum int = 0
 
func main() {
  fmt.Printf("Combien de pommes ?")
 
  num, err := fmt.Scan(&appleNum)
  fmt.Printf(appleNum)
}

Nous définissons une variable AppleNum de type entier (ligne 5). Nous affichons le message “Combien de pommes ?” pour indiquer à l'utilisateur qu'il saisisse un nombre.

Nous nous attendons donc à ce qu'ils saisissent un nombre entier : par exemple 5. Donc, à la ligne 10, on appelle la fonction de Scan().

Le code de notre programme attend alors que l'utilisateur saisisse quelque chose et appuie sur Entrée. Supposons donc que l'utilisateur saisisse 5 et frappe ↵ Entrée. Notez que la fonction Scan() prend pour argument&AppleNum, c' est-à-dire l'adresse de la variable AppleNum.

Lorsque l'utilisateur frappe 5 puis ↵ Entrée, la fonction de Scan prend ce chiffre cinq et le place dans la variable AppleNum.

A la ligne 11, on affiche la valeur saisie par l'utilisateur enregistrée dans la variable AppleNum.

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷