Interface fmt.Stringer

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 75 de 107.

A interface fmt.Stringer controla como seus tipos aparecem quando são impressos. É uma das interfaces mais implementadas em Go, definida no pacote fmt:

type Stringer interface {
    String() string
}

Quando você passa um valor para fmt.Println, fmt.Printf com %v ou funções semelhantes, o Go verifica se o tipo implementa Stringer. Se implementar, o Go chama o método String() para obter a representação textual.

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
}

Sem o método String(), a impressão exibiria o formato padrão da struct: {23.5}. Ao implementar Stringer, você controla exatamente como seu tipo se apresenta.

Isso é particularmente útil para tipos cujos valores brutos dos campos não transmitem o significado com clareza. Um tipo Duration pode ser exibido como "2h 30m" em vez de mostrar os nanossegundos brutos, ou um tipo User pode exibir um nome formatado em vez de todos os seus campos.

Desafio

Fácil

Vamos criar um sistema de controle de tempo que exibe durações em um formato fácil de entender! Você implementará a interface fmt.Stringer para controlar como seus tipos personalizados aparecem quando são impressos.

Você organizará seu código em dois arquivos:

duration.go: defina seus tipos relacionados a tempo com representações de string personalizadas.
Crie uma struct Duration que armazene um número total de minutos como um inteiro. Implemente o método String() para que, quando impressa, ela seja exibida em um formato legível, como 2h 30m para 150 minutos ou 0h 45m para 45 minutos. As horas e os minutos devem sempre ser exibidos.

Crie uma struct Task com campos para Name (string) e Time (Duration). Implemente String() em Task para exibi-la no formato [Name]: [duration], em que a duração usa seu próprio método String.
main.go: crie e exiba tarefas com suas durações.
Leia uma quantidade de tarefas e, em seguida, leia o nome e a duração em minutos de cada tarefa. Crie instâncias de Task e imprima cada uma diretamente usando fmt.Println: a interface Stringer cuidará da formatação automaticamente.

Depois de imprimir todas as tarefas, calcule e imprima o tempo total de todas as tarefas no formato:
```
Total: [duration]
```

As seguintes entradas serão fornecidas:

Linha 1: número de tarefas
Linhas seguintes: nome e minutos da tarefa (duas linhas por tarefa)

Por exemplo, dada a entrada:

3
Code Review
90
Meeting
45
Documentation
120

Sua saída deverá ser:

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

E dada a entrada:

2
Design
180
Testing
65

Sua saída deverá ser:

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

Ao implementar Stringer, seus tipos se integram perfeitamente às funções de impressão do Go. Em vez de ver campos brutos da struct, como {90}, você obtém uma saída significativa e compreensível para os usuários.

Experimente você mesmo

package main

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

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

	// Ler o número de tarefas
	line, _ := reader.ReadString('\n')
	numTasks, _ := strconv.Atoi(strings.TrimSpace(line))

	// TODO: Criar um slice para armazenar as tarefas
	// TODO: Acompanhar o total de minutos

	for i := 0; i < numTasks; i++ {
		// Ler o nome da tarefa
		name, _ := reader.ReadString('\n')
		name = strings.TrimSpace(name)

		// Ler a duração da tarefa em minutos
		minutesLine, _ := reader.ReadString('\n')
		minutes, _ := strconv.Atoi(strings.TrimSpace(minutesLine))

		// TODO: Criar um Task com o name e Duration
		// TODO: Imprimir a tarefa (fmt.Println usará a interface Stringer)
		// TODO: Adicionar minutes ao total
		_ = name
		_ = minutes
	}

	// TODO: Imprimir a duração total no formato "Total: Xh Ym"
}