Funzioni per date e numeri in GO

In questa lezione, aggiungeremo alla nostra cultura sul linguaggio Go altri due tasselli fondamentali: gestione di date e orari, con cui potremo scandire nel tempo le informazioni che maneggiamo, e funzioni matematiche.

Trattamento di informazioni data/ora

In Go esiste il package time che contiene tutto il necessario per gestire le principali categorie di funzioni legate alle date e agli orari ovvero parsing, formattazione, aritmetica.

Parsing di date e orari

Per quanto riguarda il parsing, i creatori del linguaggio hanno adottato uno stratagemma molto efficace per la definizione del formato. Piuttosto che definire metacaratteri per indicare giorno, mese anno e tutte le altre porzioni delle informazioni data/ora, hanno scelto una data simbolica, esprimibile in vari layout, che le contempla tutte: lunedì 2 gennaio 2006, ore 15 e 4 minuti e 5 secondi, settata al fuso orario MST (Mountain Standard Time, in ritardo di sette ore rispetto all'UTC).

Ad esempio, un layout è Mon Jan 2 15:04:05 MST 2006 ed esprime tutte le informazioni che abbiamo descritto con dei valori che essendo tutti diversi tra loro individuano univocamente l'elemento acui ci riferiamo.

Supponiamo di voler eseguire prima il parsing e poi la formattazione della data 12 febbraio 2022 alle ore 8:25 del mattino. Useremo le funzioni Parse e Format offerte dal modulo time. Immettiamole in un programma semplice ma completo così da poterle testare:

package main
import (
    "fmt"
    "time"
)
func main() {
    dataora,_ :=time.Parse("15:04 02/01/2006","08:25 12/02/2022")
    fmt.Println(dataora)
    messaggio:=dataora.Format("Monday 02/01/2006")
    fmt.Println(messaggio)
}

Supponendo di aver chiamato il file esempio_date.go lo eseguiamo con go run esempio_date.go ottenendo:

2022-02-12 08:25:00 +0000 UTC
Saturday 12/02/2022

Entriamo nei dettagli. Con la funzione time.Parse abbiamo detto che vogliamo interpretare la stringa "08:25 12/02/2022" con il tipo Time basandoci sul formato "15:04 02/01/2006" dove, secondo i layout spiegati in precedenza:

• 15 è l'ora.
• 04 i minuti.
• 02 il giorno.
• 01 il mese.
• 2006 l'anno.

Qualsiasi altro carattere viene preso per ciò che è, ad esempio lo slash viene riportato semplicemente come slash.

Formattazione di date e orari

Per la formattazione (espressione in stringa di un oggetto Time) abbiamo usato lo stesso meccanismo. Notiamo però come abbiamo richiesto l'indicazione del giorno della settimana.

Visto che la data modello è un lunedì abbiamo indicato "Monday" per esteso nel layout "Monday 02/01/2006". Perciò nell'output troveremo il giorno indicato come parola intera: visto che il 12 febbraio del 2022 era un sabato, troviamo nell'output "Saturday".

Calcoli con date e orari in GO

Dopo aver capito parsing e formattazione pensiamo ad un po' di aritmetica. Se volessimo, ad esempio, posticipare la nostra data di cinque ore potremmo fare come segue:

dataora.Add(time.Hour*5)

dove Hour è una Duration definita nel package in argomento e rappresenta la durata di un'ora. Si noti che le altre Duration disponibili sono Minute, Second, Millisecond, Microsecond e Nanosecond. Non esistono "tagli" più grandi come Day, Year, etc. perché si sono volute evitare potenziali confusioni tra fusi orari.

Pertanto, l'incremento di un giorno della data equivarrebbe a dataora.Add(time.Hour*24) ma anche a dataora.Add(time.Second*3600*24).

Esiste anche Sub che permette di calcolare la distanza temporale da un'altra data. Nel prossimo snippet di codice definiamo la data del 1° marzo 2022 e calcoliamo la distanza della nostra data da essa:

nuovo_mese:=time.Date(2022,03,01,0,0,0,0,time.UTC)
quanto_manca:=risultato.Sub(nuovo_mese)
fmt.Printf("A marzo mancano %v che corrispondono a %v giorni\n", quanto_manca, quanto_manca.Hours()/24)

Il messaggio di output fornito è:

A marzo mancano -394h35m0s che corrispondono a -16.44097222222222 giorni

rivelando che tra le 8:25 del 12 febbraio e l'inizio del mese di marzo successivo intercorrono 394 ore circa, equivalenti a 16 giorni. I risultati potranno poi, come si può immaginare, essere modellati e sfruttati lavorando su valori in virgola e segni algebrici.

Funzioni per i numeri

A proposito di valori in virgola e segni algebrici, il linguaggio Go dispone anche di un comodo package math che
contempla tutte le funzioni per calcoli matematici: dalla trigonometria agli esponenziali, dagli arrotondamenti ai logaritmi.

In questa lezione, vedremo - a titolo di esempio - alcune delle funzioni più comuni: calcolo del massimo (Max) e del minimo (Min), elevamento a potenza (Pow) e radice quadrata (Sqrt). Ecco il nostro codice dimostrativo:

package main
import (
    "fmt"
    "math"
)
func main() {
    numero_virgola:= 2.5
    altro_numero_virgola:= 7.6
    il_massimo:=math.Max(numero_virgola,  altro_numero_virgola)
    fmt.Printf("Il massimo tra %v e %v è %v\n", numero_virgola,  altro_numero_virgola, il_massimo)
    il_minimo:=math.Min(numero_virgola,  altro_numero_virgola)
    fmt.Printf("Il minimo tra %v e %v è %v\n", numero_virgola,  altro_numero_virgola, il_minimo)
    al_quadrato:=math.Pow(numero_virgola, 2)
    fmt.Printf("Quanto fa %v al quadrato? %v\n", numero_virgola,  al_quadrato)
    radice_quadrata:= math.Sqrt(al_quadrato)
    fmt.Printf("Calcoliamo la radice quadrata di %v: %v", al_quadrato, radice_quadrata)
}

che produce il seguente output:

Il massimo tra 2.5 e 7.6 è 7.6
Il minimo tra 2.5 e 7.6 è 2.5
Quanto fa 2.5 al quadrato? 6.25
Calcoliamo la radice quadrata di 6.25: 2.5