Introduction à Go

TP - Bases

Écrivez un programme Go qui demande à l'utilisateur de saisir une température en degrés Celsius. Le programme doit convertir cette température en degrés Fahrenheit et afficher le résultat. Utilisez la formule de conversion suivante : Fahrenheit = Celsius * 9/5 + 32.

Votre programme devrait afficher le message suivant :
"Entrez une température en degrés Celsius :"

Après que l'utilisateur ait entré la température, le programme doit afficher le résultat de la conversion dans le format suivant :
"La température en degrés Fahrenheit est : [résultat]"

Solution

package main

import "fmt"

func main() {
    var celsius float64

    fmt.Print("Entrez une température en degrés Celsius : ")
    fmt.Scan(&celsius)

    // Conversion de la température en degrés Fahrenheit
    fahrenheit := celsius*9/5 + 32

    // Affichage du résultat
    fmt.Printf("La température en degrés Fahrenheit est : %.2f", fahrenheit)
}

Explication du code :

La première ligne package main indique que le fichier est un programme exécutable et non une bibliothèque.
import "fmt" est utilisé pour importer le package fmt qui fournit des fonctions pour la saisie/sortie de base.
La fonction main() est la fonction principale qui est exécutée lorsque le programme est lancé.
Une variable celsius de type float64 est déclarée pour stocker la température en degrés Celsius saisie par l'utilisateur.
fmt.Print est utilisé pour afficher le message d'invite demandant à l'utilisateur d'entrer la température en degrés Celsius.
fmt.Scan(&celsius) est utilisé pour lire la valeur entrée par l'utilisateur et la stocker dans la variable celsius.
La conversion de la température en degrés Fahrenheit est effectuée à l'aide de la formule fahrenheit := celsius*9/5 + 32.
fmt.Printf est utilisé pour afficher le résultat de la conversion en degrés Fahrenheit. La directive de format "%.2f" est utilisée pour afficher le résultat avec 2 décimales.
L'exécution du programme se termine et affiche le résultat de la conversion de température.

TP - Structures et Tableaux

Vous devez développer un programme Go pour gérer une liste de tâches. Chaque tâche est représentée par un nom et un statut (complet ou incomplet). Le programme doit permettre à l'utilisateur de :

Ajouter une tâche à la liste en saisissant son nom.
Marquer une tâche comme complète en saisissant son nom.
Afficher la liste des tâches, en indiquant leur nom et leur statut.

Votre programme devrait afficher le message suivant : "Bienvenue dans le gestionnaire de tâches !"

Ensuite, il devrait afficher un menu avec les options suivantes :

Ajouter une tâche
Marquer une tâche comme complète
Afficher la liste des tâches
Quitter

Après chaque action effectuée par l'utilisateur, le menu devrait être réaffiché jusqu'à ce que l'utilisateur choisisse l'option "Quitter".

Solution

package main

import "fmt"

type Task struct {
    Name   string
    Status string
}

func main() {
    fmt.Println("Bienvenue dans le gestionnaire de tâches !")

    tasks := make([]Task, 0)

    for {
        fmt.Println("\nMenu:")
        fmt.Println("1. Ajouter une tâche")
        fmt.Println("2. Marquer une tâche comme complète")
        fmt.Println("3. Afficher la liste des tâches")
        fmt.Println("4. Quitter")

        var choice int
        fmt.Print("Votre choix : ")
        fmt.Scan(&choice)

        switch choice {
        case 1:
            var name string
            fmt.Print("Nom de la tâche à ajouter : ")
            fmt.Scan(&name)

            task := Task{
                Name:   name,
                Status: "Incomplet",
            }

            tasks = append(tasks, task)
            fmt.Println("Tâche ajoutée avec succès !")

        case 2:
            var name string
            fmt.Print("Nom de la tâche à marquer comme complète : ")
            fmt.Scan(&name)

            for i := range tasks {
                if tasks[i].Name == name {
                    tasks[i].Status = "Complet"
                    fmt.Println("Tâche marquée comme complète avec succès !")
                    break
                }
            }

        case 3:
            fmt.Println("Liste des tâches :")
            for _, task := range tasks {
                fmt.Printf("- %s : %s\n", task.Name, task.Status)
            }

        case 4:
            fmt.Println("Au revoir !")
            return

        default:
            fmt.Println("Choix invalide. Veuillez sélectionner une option valide.")
        }
    }
}

Explication du code :

Une structure Task est définie avec deux champs : Name pour le nom de la tâche et Status pour le statut de la tâche (complet ou incomplet).
La fonction main() est la fonction principale qui est exécutée lorsque le programme est lancé.
Un slice vide tasks est créée pour stocker les tâches ajoutées par l'utilisateur.
Le programme utilise une boucle for pour afficher le menu et traiter les choix de l'utilisateur jusqu'à ce que l'option "Quitter" soit sélectionnée.
Selon le choix de l'utilisateur, différentes actions sont effectuées :
- Pour l'option 1, l'utilisateur est invité à saisir le nom de la tâche à ajouter. Une nouvelle tâche est créée avec le statut "Incomplet" et ajoutée au slice tasks.
- Pour l'option 2, l'utilisateur est invité à saisir le nom de la tâche à marquer comme complète. Le statut de la tâche correspondante dans une tasks est mis à jour.
- Pour l'option 3, toutes les tâches dans les tasks sont affichées avec leur nom et leur statut.
- Pour l'option 4, le programme se termine et affiche "Au revoir !".
- Si l'utilisateur choisit une option invalide, un message d'erreur est affiché.