Interfacce Stringer ed Error

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

La libreria standard di Go definisce due interfacce che userai continuamente: fmt.Stringer e error. Entrambe sono semplici interfacce con un singolo metodo, che permettono ai tuoi tipi di integrarsi efficacemente con le funzionalità integrate di Go.

L’interfaccia Stringer si trova nel pacchetto fmt e richiede un solo metodo:

type Stringer interface {
    String() string
}

Quando implementi String() sul tuo tipo, funzioni come fmt.Println la usano automaticamente per visualizzare il tuo valore:

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    fmt.Println(p)  // Alice (30 anni)
}

L’interfaccia error è altrettanto semplice e richiede un metodo Error() che restituisca una stringa:

type error interface {
    Error() string
}

Qualsiasi tipo con un metodo Error() può essere usato come valore di errore in Go. Questo ti permette di creare tipi di errore personalizzati con un contesto aggiuntivo:

type ValidationError struct {
    Field   string
    Message string
}

func (e ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Message)
}

func main() {
    err := ValidationError{Field: "email", Message: "invalid format"}
    fmt.Println(err)  // email: invalid format
}

Queste due interfacce dimostrano la filosofia di Go: interfacce piccole e mirate che sbloccano comportamenti potenti tramite l’implementazione implicita.

Sfida

Facile

Costruiamo un sistema di monitoraggio della temperatura che utilizza sia le interfacce Stringer sia error per fornire un output leggibile e una gestione degli errori significativa.

Organizzerai il codice in due file:

temperature.go: crea una struct Temperature con i campi Value (float64) e Unit (string). Implementa il metodo String() in modo che, quando viene stampata, la temperatura sia visualizzata in un formato leggibile. Crea anche una struct TemperatureError con i campi Temp (float64) e Reason (string) e implementa il metodo Error() per fornire messaggi di errore descrittivi.
main.go: crea una funzione chiamata ValidateTemperature che accetta una Temperature e restituisce un errore se la temperatura non è valida. Una temperatura non è valida se è inferiore allo zero assoluto (-273.15 per Celsius, -459.67 per Fahrenheit). Se è valida, la funzione restituisce nil. Leggi i dati della temperatura dall'input, crea una Temperature, convalidala e stampa l'output appropriato.

Verranno forniti i seguenti input:

Riga 1: valore della temperatura (float)
Riga 2: unità (C per Celsius o F per Fahrenheit)

Il tuo metodo String() dovrebbe restituire il formato:

[Value] degrees [Unit]

Dove Unit è la parola completa "Celsius" o "Fahrenheit", in base all'input.

Il tuo metodo Error() dovrebbe restituire il formato:

invalid temperature [Temp]: [Reason]

Se la temperatura è valida, stampa la Temperature usando fmt.Println (che utilizzerà il tuo metodo String()). Se non è valida, stampa l'errore (che utilizzerà il tuo metodo Error()).

Ad esempio, dati 25.5 e C, l'output dovrebbe essere:

25.5 degrees Celsius

Dati -500 e F, l'output dovrebbe essere:

invalid temperature -500: below absolute zero

Usa "below absolute zero" come motivo quando la temperatura è troppo bassa.

Provalo tu

package main

import (
	"fmt"
)

// ValidateTemperature verifica se una temperatura è valida
// Restituisce un errore se la temperatura è inferiore allo zero assoluto
// Zero assoluto: -273.15 per Celsius, -459.67 per Fahrenheit
func ValidateTemperature(t Temperature) error {
	// TODO: Implementare la logica di validazione
	// Verificare se la temperatura è inferiore allo zero assoluto in base all'unità
	// Restituire un TemperatureError se non è valida, nil se è valida
	return nil
}

func main() {
	var value float64
	var unit string
	fmt.Scanln(&value)
	fmt.Scanln(&unit)

	// TODO: Creare una struct Temperature con i valori di input

	// TODO: Validare la temperatura usando ValidateTemperature

	// TODO: Se si verifica un errore, stamparlo
	// Altrimenti, stampare la temperatura (usando il metodo String())
}