Interfaz fmt.Stringer

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy. Lección 75 de 107.

La interfaz fmt.Stringer controla cómo aparecen tus tipos al imprimirlos. Es una de las interfaces más implementadas en Go, definida en el paquete fmt:

type Stringer interface {
    String() string
}

Cuando pasas un valor a fmt.Println, fmt.Printf con %v o funciones similares, Go comprueba si el tipo implementa Stringer. Si es así, Go llama al método String() para obtener la representación 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
}

Sin el método String(), la impresión mostraría el formato de estructura predeterminado: {23.5}. Al implementar Stringer, controlas exactamente cómo se presenta tu tipo.

Esto es especialmente útil para los tipos cuyos valores de campo sin procesar no transmiten claramente su significado. Un tipo Duration podría mostrarse como "2h 30m" en lugar de mostrar los nanosegundos sin procesar, o un tipo User podría mostrar un nombre con formato en lugar de todos sus campos.

Desafío

Fácil

¡Construyamos un sistema de seguimiento del tiempo que muestre las duraciones en un formato fácil de entender! Implementarás la interfaz fmt.Stringer para controlar cómo aparecen tus tipos personalizados al imprimirse.

Organizarás tu código en dos archivos:

duration.go: Define tus tipos relacionados con el tiempo, con representaciones de cadena personalizadas.
Crea una estructura Duration que almacene un número total de minutos como un entero. Implementa el método String() para que, al imprimirse, muestre un formato legible como 2h 30m para 150 minutos o 0h 45m para 45 minutos. Las horas y los minutos siempre deben mostrarse.

Crea una estructura Task con campos para Name (cadena) y Time (Duration). Implementa String() en Task para mostrar el formato [Name]: [duration], donde la duración utiliza su propio método String.
main.go: Crea y muestra tareas con sus duraciones.
Lee una cantidad de tareas y, después, para cada tarea, lee su nombre y su duración en minutos. Crea instancias de Task e imprime cada una directamente usando fmt.Println: la interfaz Stringer se encargará automáticamente del formato.

Después de imprimir todas las tareas, calcula e imprime el tiempo total de todas las tareas con el formato:
```
Total: [duration]
```

Se proporcionarán las siguientes entradas:

Línea 1: Número de tareas
Líneas siguientes: Nombre de la tarea y minutos (dos líneas por tarea)

Por ejemplo, dada la siguiente entrada:

3
Code Review
90
Meeting
45
Documentation
120

Tu salida debería ser:

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

Y dada la siguiente entrada:

2
Design
180
Testing
65

Tu salida debería ser:

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

Al implementar Stringer, tus tipos se integran perfectamente con las funciones de impresión de Go. En lugar de ver campos sin procesar de la estructura, como {90}, obtienes una salida significativa que tiene sentido para los usuarios.

Pruébalo tú mismo

package main

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

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

	// Lee el número de tareas
	line, _ := reader.ReadString('\n')
	numTasks, _ := strconv.Atoi(strings.TrimSpace(line))

	// TODO: Crea un slice para almacenar las tareas
	// TODO: Lleva la cuenta del total de minutos

	for i := 0; i < numTasks; i++ {
		// Lee el nombre de la tarea
		name, _ := reader.ReadString('\n')
		name = strings.TrimSpace(name)

		// Lee la duración de la tarea en minutos
		minutesLine, _ := reader.ReadString('\n')
		minutes, _ := strconv.Atoi(strings.TrimSpace(minutesLine))

		// TODO: Crea un Task con el name y Duration
		// TODO: Imprime la tarea (fmt.Println usará la interfaz Stringer)
		// TODO: Añade minutes al total
		_ = name
		_ = minutes
	}

	// TODO: Imprime la duración total en formato "Total: Xh Ym"
}