Terminer une tâche

Fait partie de la section Logique & Flux du Journey GO de Coddy — leçon 23 sur 68.

Défi

Facile

Dans cette partie de votre système de gestion de tâches, vous allez implémenter la possibilité de marquer des tâches comme terminées. Ce défi se concentre sur l'utilisation de récepteurs de pointeurs pour modifier les données originales de la tâche, démontrant comment les pointeurs vous permettent de mettre à jour les champs d'une structure de manière permanente.

Note importante : Étant donné que les noms de tâches peuvent contenir des espaces (comme "Buy groceries"), vous devrez utiliser bufio.Scanner pour lire des lignes entières d'entrée. La fonction fmt.Scanf s'arrête de lire au premier espace, ce qui corromprait les noms de tâches contenant des espaces. Utilisez bufio.NewScanner(os.Stdin) et appelez scanner.Scan() suivi de scanner.Text() pour lire des lignes complètes.

Vous recevrez trois entrées :

Une chaîne représentant le nombre de tâches (par exemple, "4")
Une chaîne contenant les données des tâches au format : "name1:status1,name2:status2,name3:status3" où le statut est soit "true" soit "false" (par exemple, "Buy groceries:false,Call dentist:true,Finish project:false,Review code:false")
Une chaîne représentant l'index de la tâche à terminer (par exemple, "2" pour la troisième tâche, en utilisant une indexation basée sur 0)

Votre tâche consiste à :

Définir la même structure Task que dans les défis précédents avec les champs Name (string) et Completed (bool)
Créer une fonction appelée completeTask qui prend un pointeur vers une tranche (slice) de structures Task et un index (int) comme paramètres
À l'intérieur de la fonction completeTask, modifier le champ Completed de la tâche à l'index donné pour le mettre à true
Utiliser bufio.Scanner pour lire correctement les lignes d'entrée :
- Créer un scanner : scanner := bufio.NewScanner(os.Stdin)
- Pour chaque ligne d'entrée : appeler scanner.Scan() puis scanner.Text()
- Cela garantit que les noms de tâches avec des espaces sont lus correctement
Analyser les données de tâche de la deuxième entrée pour créer votre tranche de tâches :
- Diviser l'entrée par des virgules pour obtenir les entrées de tâches individuelles
- Pour chaque entrée, diviser par deux-points pour séparer le nom et le statut
- Convertir la chaîne de statut en booléen ("true" devient true, "false" devient false)
Convertir la troisième chaîne d'entrée en un entier pour obtenir l'index de la tâche
Appeler votre fonction completeTask avec un pointeur vers votre tranche et l'index
Après avoir terminé la tâche, afficher toutes les tâches en utilisant le même format que le défi précédent :
- Pour les tâches terminées : "[x] [task_name]"
- Pour les tâches incomplètes : "[ ] [task_name]"
Imprimer un message de confirmation : "Task '[task_name]' marked as completed!"
Imprimer le résumé mis à jour : "Total: [total_count] tasks ([completed_count] completed, [incomplete_count] remaining)"

Utilisez le package strconv pour convertir la chaîne d'index en un entier. Ce défi démontre comment les récepteurs de pointeurs vous permettent de modifier la structure de données originale, en apportant des modifications permanentes à votre liste de tâches qui persistent après le retour de la fonction.

Essayez vous-même

package main

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

type Task struct {
	Name      string
	Completed bool
}

func viewAllTasks(tasks []Task) {
	for _, task := range tasks {
		if task.Completed {
			fmt.Printf("[x] %s\n", task.Name)
		} else {
			fmt.Printf("[ ] %s\n", task.Name)
		}
	}
}

func main() {
	var numTasksStr string
	fmt.Scanln(&numTasksStr)
	numTasks, _ := strconv.Atoi(numTasksStr)

	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	taskData := scanner.Text()

	var tasks []Task
	taskEntries := strings.Split(taskData, ",")

	for _, entry := range taskEntries {
		parts := strings.Split(entry, ":")
		if len(parts) >= 2 {
			name := parts[0]
			completed, _ := strconv.ParseBool(parts[1])
			task := Task{
				Name:      name,
				Completed: completed,
			}
			tasks = append(tasks, task)
		}
	}

	viewAllTasks(tasks)

	completedCount := 0
	for _, task := range tasks {
		if task.Completed {
			completedCount++
		}
	}

	incompleteCount := numTasks - completedCount
	fmt.Printf("Total: %d tasks (%d completed, %d remaining)\n", numTasks, completedCount, incompleteCount)
}

Toutes les leçons de Logique & Flux

1Structures de contrôle avancées

Switch avec `fallthrough`Sortir de boucles imbriquées Continuer une boucle spécifique L'instruction `goto`Récapitulatif - Contrôle de boucle avancé

4Projet : Liste de tâches simple

Configuration du projet Ajouter une tâche

Afficher toutes les tâches

Terminer une tâche Leçon de projet

Supprimer une tâche

Assemblage final

7Gestion des erreurs en profondeur

Types d'erreurs personnalisés Envelopper des erreurs avec `%w`Désenvelopper avec `errors.Is`Désenvelopper avec `errors.As`Comprendre `panic`Utiliser `recover`Récapitulatif - Division sécurisée

10Travailler avec le temps

Obtenir l'heure actuelle Créer une heure spécifique Formatage de l'heure Parsing de chaînes de temps Durée temporelle Arithmétique temporelle Sleep et Tickers Récapitulatif - Minuteur simple