Interfaccia fmt.Stringer

Fa parte della sezione Programmazione orientata agli oggetti del percorso GO di Coddy. Lezione 75 di 107.

L’interfaccia fmt.Stringer controlla come appaiono i tuoi tipi quando vengono stampati. È una delle interfacce implementate più comunemente in Go, definita nel pacchetto fmt:

type Stringer interface {
    String() string
}

Quando passi un valore a fmt.Println, a fmt.Printf con %v o a funzioni simili, Go verifica se il tipo implementa Stringer. Se sì, Go chiama il metodo String() per ottenere la rappresentazione testuale.

type Temperature struct {
    Celsius float64
}

func (t Temperature) String() string {
    return fmt.Sprintf("%.1f°C", t.Celsius)
}

func main() {
    temp := Temperature{Celsius: 23.5}
    fmt.Println(temp)  // 23.5°C
}

Senza il metodo String(), la stampa mostrerebbe il formato predefinito della struct: {23.5}. Implementando Stringer, controlli esattamente come viene presentato il tuo tipo.

Questo è particolarmente utile per i tipi i cui valori grezzi dei campi non comunicano chiaramente il loro significato. Un tipo Duration potrebbe essere visualizzato come "2h 30m" invece di mostrare i nanosecondi grezzi, oppure un tipo User potrebbe mostrare un nome formattato invece di tutti i suoi campi.

Sfida

Facile

Costruiamo un sistema di monitoraggio del tempo che mostra le durate in un formato intuitivo! Implementerai l'interfaccia fmt.Stringer per controllare come vengono visualizzati i tuoi tipi personalizzati quando vengono stampati.

Organizzerai il codice in due file:

duration.go: definisci i tuoi tipi relativi al tempo con rappresentazioni testuali personalizzate.
Crea una struct Duration che memorizza il numero totale di minuti come intero. Implementa il metodo String() in modo che, quando viene stampato, mostri una rappresentazione leggibile come 2h 30m per 150 minuti o 0h 45m per 45 minuti. Ore e minuti devono essere mostrati sempre.

Crea una struct Task con i campi Name (stringa) e Time (Duration). Implementa String() su Task per visualizzarlo nel formato [Name]: [duration], dove la durata usa il proprio metodo String.
main.go: crea e visualizza attività con le relative durate.
Leggi il numero di attività, poi leggi il nome e la durata in minuti di ciascuna attività. Crea istanze di Task e stampa direttamente ciascuna usando fmt.Println: l'interfaccia Stringer gestirà automaticamente la formattazione.

Dopo aver stampato tutte le attività, calcola e stampa il tempo totale di tutte le attività nel formato:
```
Total: [duration]
```

Verranno forniti i seguenti input:

Riga 1: numero di attività
Righe successive: nome dell'attività e minuti (due righe per attività)

Ad esempio, dato:

3
Code Review
90
Meeting
45
Documentation
120

L'output dovrebbe essere:

Code Review: 1h 30m
Meeting: 0h 45m
Documentation: 2h 0m
Total: 4h 15m

E dato:

2
Design
180
Testing
65

L'output dovrebbe essere:

Design: 3h 0m
Testing: 1h 5m
Total: 4h 5m

Implementando Stringer, i tuoi tipi si integrano perfettamente con le funzioni di stampa di Go. Invece di vedere i campi grezzi della struct, come {90}, ottieni un output significativo e comprensibile per gli utenti.

Provalo tu

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Leggi il numero di attività
	line, _ := reader.ReadString('\n')
	numTasks, _ := strconv.Atoi(strings.TrimSpace(line))

	// TODO: Crea uno slice per memorizzare le attività
	// TODO: Tieni traccia del totale dei minuti

	for i := 0; i < numTasks; i++ {
		// Leggi il nome dell'attività
		name, _ := reader.ReadString('\n')
		name = strings.TrimSpace(name)

		// Leggi la durata dell'attività in minuti
		minutesLine, _ := reader.ReadString('\n')
		minutes, _ := strconv.Atoi(strings.TrimSpace(minutesLine))

		// TODO: Crea un Task con il nome e Duration
		// TODO: Stampa l'attività (fmt.Println userà l'interfaccia Stringer)
		// TODO: Aggiungi i minuti al totale
		_ = name
		_ = minutes
	}

	// TODO: Stampa la durata totale nel formato "Total: Xh Ym"
}