Manipulation avancée de données en Go

Structures

https://www.simplilearn.com/tutorials/golang-tutorial/golang-struct

https://devopssec.fr/article/structures-et-methodes-golang

Fichiers

https://devopssec.fr/article/structures-et-methodes-golang

https://www.golinuxcloud.com/golang-os/

https://gobyexample.com/reading-files

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 :

1. Ajouter une tâche à la liste en saisissant son nom.
2. Marquer une tâche comme complète en saisissant son nom.
3. 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 :

1. Ajouter une tâche
2. Marquer une tâche comme complète
3. Afficher la liste des tâches
4. 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é.

TP - Fichiers

Vous devez développer un programme Go pour gérer une liste de contacts. Chaque contact est représenté par un nom et un numéro de téléphone. Le programme doit permettre à l'utilisateur de :

1. Ajouter un contact en saisissant son nom et son numéro de téléphone.
2. Rechercher un contact par son nom et afficher son numéro de téléphone.
3. Afficher la liste complète des contacts, en indiquant leur nom et leur numéro de téléphone.
4. Enregistrer les contacts dans un fichier.
5. Charger les contacts à partir d'un fichier lors du démarrage du programme.

Votre programme devrait afficher le message suivant : "Bienvenue dans le gestionnaire de contacts !"

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

1. Ajouter un contact
2. Rechercher un contact
3. Afficher la liste des contacts
4. Enregistrer les contacts dans un fichier
5. Charger les contacts à partir d'un fichier
6. 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

Code solution expliqué :

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

type Contact struct {
	Name  string
	Phone string
}

func main() {
	fmt.Println("Bienvenue dans le gestionnaire de contacts !")

	contacts := make(map[string]string)

	loadContactsFromFile(contacts)

	for {
		fmt.Println("\nMenu:")
		fmt.Println("1. Ajouter un contact")
		fmt.Println("2. Rechercher un contact")
		fmt.Println("3. Afficher la liste des contacts")
		fmt.Println("4. Enregistrer les contacts dans un fichier")
		fmt.Println("5. Charger les contacts à partir d'un fichier")
		fmt.Println("6. Quitter")

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

		switch choice {
		case 1:
			var name, phone string
			fmt.Print("Nom du contact : ")
			scanner := bufio.NewScanner(os.Stdin)
			scanner.Scan()
			name = scanner.Text()
			fmt.Print("Numéro de téléphone : ")
			scanner.Scan()
			phone = scanner.Text()
			contacts[name] = phone
			fmt.Println("Contact ajouté avec succès !")

		case 2:
			var name string
			fmt.Print("Nom du contact à rechercher : ")
			scanner := bufio.NewScanner(os.Stdin)
			scanner.Scan()
			name = scanner.Text()
			phone, found := contacts[name]
			if found {
				fmt.Printf("Numéro de téléphone de %s : %s\n", name, phone)
			} else {
				fmt.Println("Contact non trouvé.")
			}

		case 3:
			fmt.Println("Liste des contacts :")
			for name, phone := range contacts {
				fmt.Printf("- %s : %s\n", name, phone)
			}

		case 4:
			saveContactsToFile(contacts)
			fmt.Println("Contacts enregistrés avec succès !")

		case 5:
			loadContactsFromFile(contacts)
			fmt.Println("Contacts chargés avec succès !")

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

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

func loadContactsFromFile(contacts map[string]string) {
	file, err := os.Open("contacts.txt")
	if err != nil {
		return
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		parts := strings.Split(line, ":")
		if len(parts) == 2 {
			name := strings.TrimSpace(parts[0])
			phone := strings.TrimSpace(parts[1])
			contacts[name] = phone
		}
	}

	if err := scanner.Err(); err != nil {
		fmt.Println("Erreur lors du chargement des contacts :", err)
	}
}

func saveContactsToFile(contacts map[string]string) {
	file, err := os.Create("contacts.txt")
	if err != nil {
		fmt.Println("Erreur lors de l'enregistrement des contacts :", err)
		return
	}
	defer file.Close()

	writer := bufio.NewWriter(file)
	for name, phone := range contacts {
		line := fmt.Sprintf("%s: %s\n", name, phone)
		_, err := writer.WriteString(line)
		if err != nil {
			fmt.Println("Erreur lors de l'écriture dans le fichier :", err)
		}
	}

	writer.Flush()
}

Explication du code :

• Une structure Contact est définie avec deux champs : Name pour le nom du contact et Phone pour son numéro de téléphone.
• La fonction main() est la fonction principale qui est exécutée lorsque le programme est lancé.
• Une map contacts est utilisée pour stocker les contacts, où la clé est le nom du contact et la valeur est son numéro de téléphone.
• La fonction loadContactsFromFile() est utilisée pour charger les contacts à partir d'un fichier contacts.txt. Chaque ligne du fichier doit être au format "Nom: Numéro".
• La fonction saveContactsToFile() est utilisée pour enregistrer les contacts dans le fichier contacts.txt. Chaque contact est écrit sur une ligne séparée avec le format "Nom: Numéro".
• 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 et le numéro de téléphone du contact, puis le contact est ajouté à la map contacts.
  • Pour l'option 2, l'utilisateur est invité à saisir le nom du contact à rechercher. Si le contact est trouvé dans la map contacts, son numéro de téléphone est affiché.
  • Pour l'option 3, tous les contacts dans la map contacts sont affichés avec leur nom et leur numéro de téléphone.
  • Pour l'option 4, les contacts sont enregistrés dans le fichier contacts.txt en utilisant la fonction saveContactsToFile().
  • Pour l'option 5, les contacts sont chargés à partir du fichier contacts.txt en utilisant la fonction loadContactsFromFile().
  • Pour l'option 6, le programme se termine et affiche "Au revoir !".
  • Si l'utilisateur choisit une option invalide, un message d'erreur est affiché.