Supprimer une tâche

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

Défi

Facile

Dans cette partie de votre système de gestion de tâches, vous allez implémenter la possibilité de supprimer des tâches de votre liste. Ce défi se concentre sur la manipulation des slices en utilisant la fonction append pour reconstruire une slice sans un élément spécifique, démontrant ainsi comment supprimer définitivement des éléments de votre structure de données.

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:true")
Une chaîne représentant l'index de la tâche à supprimer (par exemple, "1" pour la deuxième tâche, en utilisant une indexation basée sur 0)

Votre tâche consiste à :

Définir la même structure Task des défis précédents avec les champs Name (string) et Completed (bool)
Créer une fonction appelée removeTask qui prend une slice de structures Task et un index (int) comme paramètres
À l'intérieur de la fonction removeTask, retourner une nouvelle slice avec la tâche à l'index donné supprimée en utilisant append pour combiner les éléments avant et après l'index cible
Analyser les données de tâche de la deuxième entrée pour créer votre slice 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 un 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
Stocker le nom de la tâche à supprimer avant d'appeler la fonction removeTask
Appeler votre fonction removeTask avec votre slice et l'index, en stockant la slice retournée
Après avoir supprimé la tâche, afficher toutes les tâches restantes en utilisant le même format que les défis précédents :
- Pour les tâches terminées : "[x] [task_name]"
- Pour les tâches incomplètes : "[ ] [task_name]"
Afficher un message de confirmation : "Task '[task_name]' removed successfully!"
Afficher 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 utiliser append pour reconstruire des slices en combinant des portions avant et après un élément cible, supprimant ainsi efficacement des éléments de votre collection tout en maintenant l'ordre des éléments restants.

Essayez vous-même

package main

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

type Task struct {
	Name      string
	Completed bool
}

func completeTask(tasks *[]Task, index int) {
	(*tasks)[index].Completed = true
}

func main() {
	// Read input using bufio.Scanner to handle spaces properly
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	_ = scanner.Text() // Read but don't use the number of tasks
	
	scanner.Scan()
	taskDataStr := scanner.Text()
	
	scanner.Scan()
	indexStr := scanner.Text()
	
	// Parse task data
	taskEntries := strings.Split(taskDataStr, ",")
	tasks := make([]Task, len(taskEntries))
	
	for i, entry := range taskEntries {
		parts := strings.Split(entry, ":")
		if len(parts) >= 2 {
			name := parts[0]
			status := parts[1] == "true"
			tasks[i] = Task{Name: name, Completed: status}
		}
	}
	
	// Convert index string to integer
	index, _ := strconv.Atoi(indexStr)
	
	// Complete the task
	taskName := tasks[index].Name
	completeTask(&tasks, index)
	
	// Display all tasks
	for _, task := range tasks {
		if task.Completed {
			fmt.Printf("[x] %s\n", task.Name)
		} else {
			fmt.Printf("[ ] %s\n", task.Name)
		}
	}
	
	// Print confirmation message
	fmt.Printf("Task '%s' marked as completed!\n", taskName)
	
	// Count completed and incomplete tasks
	completedCount := 0
	for _, task := range tasks {
		if task.Completed {
			completedCount++
		}
	}
	incompleteCount := len(tasks) - completedCount
	
	// Print summary
	fmt.Printf("Total: %d tasks (%d completed, %d remaining)\n", len(tasks), 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

Supprimer une tâche Leçon de projet

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