Utilisation de l'instruction goto

Introduction

Par rapport aux instructions de branchement et de boucle, l'instruction goto est plus flexible. Elle nous permet d'effectuer des sauts inconditionnels au sein de la même fonction. Bien que l'utilisation excessive de goto puisse réduire la lisibilité du code, son principal avantage réside dans sa flexibilité. Lorsqu'elle est utilisée de manière appropriée, elle non seulement améliore l'efficacité du programme, mais rend également le code plus concis et élégant dans certains scénarios.

Dans ce lab (atelier), vous apprendrez les bases de l'utilisation de l'instruction goto en Go, ainsi que son application dans différents scénarios, comme le remplacement des instructions break, la mise en œuvre de boucles et la sortie de boucles imbriquées.

Points de connaissance :

Syntaxe et utilisation de goto
Applications pratiques de goto dans les programmes Go

Comprendre la syntaxe de goto

La syntaxe de goto est la suivante :

// Syntax 1: Jumping forward
goto label
...
label: code block

// Syntax 2: Jumping backward
label: code block
goto label

En Go, goto offre de la flexibilité car elle peut effectuer des sauts tant en avant qu'en arrière dans le code. L'étiquette (label) est essentiellement un marqueur qui indique où le contrôle du programme doit sauter. Les étiquettes sont sensibles à la casse, et il est recommandé d'utiliser des lettres majuscules pour les étiquettes afin d'améliorer la lisibilité.

Remarque : La déclaration et l'utilisation des étiquettes doivent toutes deux se produire au sein de la même fonction.

Exemple : Un programme simple utilisant `goto`

Explorons un programme simple qui démontre l'utilisation de goto. Dans cet exemple, le programme saute certaines lignes et saute directement à l'étiquette :

Créez un nouveau fichier Go nommé goto.go en exécutant les commandes suivantes :

cd ~/project
touch goto.go

Ouvrez le fichier et écrivez le code suivant :

package main

import "fmt"

func main() {
    fmt.Println(1)  // Affiche le nombre 1
    goto NEXT        // Saute à l'étiquette "NEXT"
    fmt.Println(2)  // Cette ligne est sautée
NEXT:
    fmt.Println(3)  // Affiche le nombre 3
}

Le programme commence par afficher le nombre 1.
Il rencontre ensuite l'instruction goto NEXT, qui provoque un saut immédiat à l'étiquette NEXT.
En conséquence, la ligne fmt.Println(2) est sautée, et le programme reprend son exécution à partir de l'étiquette NEXT, affichant le nombre 3.

Exécutez le programme :

go run goto.go

Observez la sortie :

1
3

Cet exemple simple montre comment goto peut être utilisée pour contrôler le flux du programme de manière simple.

Remplacer break par goto

Dans certaines situations, goto peut être utilisée comme substitut à l'instruction break dans les boucles, offrant de la flexibilité pour sortir des boucles en fonction de conditions spécifiques.

Exemple : Utilisation de `goto` pour sortir d'une boucle

Créez un nouveau fichier Go nommé break_with_goto.go :

cd ~/project
touch break_with_goto.go

Écrivez le code suivant dans le fichier :

package main

import "fmt"

func main() {
    for i := 0; ; i++ {         // Une boucle infinie
        if i == 10 {            // Condition pour sortir de la boucle
            goto END            // Sauter à l'étiquette "END"
        }
        fmt.Print(i)            // Afficher la valeur actuelle de i
    }
END:
    fmt.Println("END")          // Afficher "END" après avoir quitté la boucle
}

Le programme lance une boucle infinie avec for i := 0; ; i++.
À l'intérieur de la boucle, il vérifie si i est égal à 10. Si c'est le cas, il saute à l'étiquette END, ce qui permet de sortir de la boucle.
Avant de sauter, il affiche les valeurs de i de 0 à 9.
Après avoir quitté la boucle, le programme affiche END.

Exécutez le programme :

go run break_with_goto.go

Observez la sortie :

0123456789END

Cet exemple montre comment goto peut remplacer une instruction break dans une boucle, offrant une autre façon de terminer les boucles.

Implémentation d'une boucle for en utilisant goto

goto peut également être utilisée pour implémenter manuellement une boucle. Bien que Go propose des boucles for natives, cet exercice montre comment goto peut imiter le comportement d'une boucle.

Exemple : Une boucle `for` avec `goto`

Créez un nouveau fichier nommé for_loop_with_goto.go :

cd ~/project
touch for_loop_with_goto.go

Écrivez le code suivant :

package main

import "fmt"

func main() {
    var i = 0            // Initialize a variable i
BEGIN:
    fmt.Printf("%d ", i) // Print the current value of i
    if i == 9 {          // Check if i has reached 9
        goto END         // Exit the loop if true
    }
    i++                  // Increment i
    goto BEGIN           // Jump back to the label "BEGIN"
END:
}

Le programme initialise i à 0 et lance la boucle en utilisant l'étiquette BEGIN.
Il affiche la valeur de i et vérifie si elle a atteint 9.
Si ce n'est pas le cas, il incrémente i et saute en arrière à l'étiquette BEGIN, répétant le processus.
Une fois que i est égal à 9, le programme saute à l'étiquette END, mettant fin à la boucle.

Exécutez le programme :

go run for_loop_with_goto.go

Observez la sortie :

0 1 2 3 4 5 6 7 8 9

Cet exemple illustre comment goto peut imiter les structures de boucle.

Sortir de boucles imbriquées avec goto

Sortir de boucles imbriquées peut être fastidieux en utilisant break, car cela nécessite généralement une logique et des variables supplémentaires. goto simplifie ce processus en permettant des sauts directs en dehors de plusieurs boucles.

Exemple : Utilisation de `goto` pour sortir de boucles imbriquées

Créez un nouveau fichier nommé nested_loop_with_goto.go :

cd ~/project
touch nested_loop_with_goto.go

Écrivez le code suivant :

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {      // Outer loop
        for j := 0; j < 5; j++ {  // Inner loop
            if j == 3 {           // Exit condition
                goto END          // Jump to the "END" label
            }
            fmt.Println(i, j)     // Print the current values of i and j
        }
    }
END:
}

Le programme commence avec une boucle imbriquée : une boucle externe pour i et une boucle interne pour j.
À l'intérieur de la boucle interne, il vérifie si j est égal à 3. Si c'est le cas, le programme saute à l'étiquette END, sortant des deux boucles.
En conséquence, le programme affiche les paires (i, j) seulement jusqu'à ce que j soit égal à 2.

Exécutez le programme :

go run nested_loop_with_goto.go

Observez la sortie :

0 0
0 1
0 2

Cette approche est beaucoup plus propre que d'utiliser plusieurs instructions break ou des indicateurs (flags), surtout dans des boucles profondément imbriquées.

Si nous utilisons l'instruction break pour implémenter ce programme, comme montré ci-dessous :

package main

import "fmt"

func main() {
    // Check variable
    var check = false
    // First loop
    for i := 0; i < 5; i++ {
        // Second loop
        for j := 0; j < 5; j++ {
            if j == 3 {
                // Exit the second loop
                check = true
                break
            }
            fmt.Println(i, j)
        }
        // Determine whether to exit the first loop
        if check == true {
            break
        }
    }
}

Résumé

Dans ce laboratoire (lab), nous avons exploré l'instruction goto en Go et ses diverses applications. Voici ce que nous avons appris :

L'instruction goto permet des sauts inconditionnels vers des étiquettes (labels) spécifiées au sein de la même fonction.
Elle peut être utilisée pour remplacer les instructions break, implémenter des boucles et sortir plus efficacement de boucles imbriquées.
Bien que goto offre de la flexibilité et de la concision, elle devrait être utilisée avec modération pour éviter de réduire la lisibilité du code.

En comprenant et en utilisant efficacement goto, vous pouvez simplifier certains scénarios de flux de contrôle dans vos programmes. Cependant, toujours cherchez à maintenir la clarté et la maintenabilité de votre code!