Go Academy · Lezione

Elementi essenziali del package time

Lavorare con orari, durate e formattazione

Elementi essenziali del package time è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

time.Time — Il tipo fondamentale

Il tipo centrale del pacchetto time è time.Time. Ottenga l'ora corrente con time.Now():

package main
import ("fmt"; "time")

func main() {
    now := time.Now()
    fmt.Println(now)              // 2024-01-15 10:30:00.123456789 +0000 UTC
    fmt.Println(now.Year())       // 2024
    fmt.Println(now.Month())      // January
    fmt.Println(now.Day())        // 15
    fmt.Println(now.Hour())       // 10
    fmt.Println(now.Minute())     // 30
    fmt.Println(now.Weekday())    // Monday
}

time.Duration

time.Duration rappresenta il tempo trascorso in nanosecondi. Utilizzi costanti tipizzate per migliorare la leggibilità:

package main
import ("fmt"; "time")

func main() {
    d := 2*time.Hour + 30*time.Minute + 15*time.Second
    fmt.Println(d)              // 2h30m15s
    fmt.Println(d.Hours())      // 2.504166...
    fmt.Println(d.Minutes())    // 150.25
    fmt.Println(d.Seconds())    // 9015
    fmt.Println(d.Milliseconds()) // 9015000
}

time.Add e time.Sub

Aggiunga una durata a un orario oppure sottragga due orari per ottenere una durata:

package main
import ("fmt"; "time")

func main() {
    now := time.Now()

    tomorrow := now.Add(24 * time.Hour)
    fmt.Println(tomorrow.Format("2006-01-02"))

    deadline := now.Add(30 * time.Minute)
    remaining := time.Until(deadline)  // alias for deadline.Sub(now)
    fmt.Printf("%.0f minutes left\n", remaining.Minutes())
}

Formattazione e parsing degli orari

Go utilizza l'orario di riferimento Mon Jan 2 15:04:05 MST 2006 come modello di formattazione, con i valori da 1 a 7 nell'ordine:

package main
import ("fmt"; "time")

func main() {
    now := time.Now()

    // Format
    fmt.Println(now.Format("2006-01-02"))          // 2024-01-15
    fmt.Println(now.Format("02/01/2006 15:04:05")) // 15/01/2024 10:30:00
    fmt.Println(now.Format(time.RFC3339))          // 2024-01-15T10:30:00Z
    fmt.Println(now.Format(time.Kitchen))          // 10:30AM
}

time.Parse — Analisi delle stringhe

Analizzi una stringa trasformandola in un time.Time utilizzando lo stesso modello di riferimento:

package main
import ("fmt"; "time")

func main() {
    s := "2024-01-15"
    t, err := time.Parse("2006-01-02", s)
    if err != nil {
        fmt.Println("parse error:", err)
        return
    }
    fmt.Println(t.Year(), t.Month(), t.Day()) // 2024 January 15

    // Parse RFC3339 (ISO 8601):
    t2, _ := time.Parse(time.RFC3339, "2024-01-15T10:30:00Z")
    fmt.Println(t2)
}

time.Sleep e i timer

Sospenda l'esecuzione con time.Sleep; crei timer eseguiti una sola volta con time.NewTimer:

package main
import ("fmt"; "time")

func main() {
    start := time.Now()
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("slept for %v\n", time.Since(start))

    // One-shot timer
    timer := time.NewTimer(200 * time.Millisecond)
    <-timer.C  // blocks until timer fires
    fmt.Println("timer fired")
}

time.Ticker per gli eventi ripetuti

time.NewTicker invia valori sul proprio canale a intervalli regolari:

package main
import ("fmt"; "time")

func main() {
    ticker := time.NewTicker(500 * time.Millisecond)
    defer ticker.Stop()  // always stop to avoid goroutine leak

    for i := 0; i < 3; i++ {
        t := <-ticker.C
        fmt.Println("tick at", t.Format("15:04:05.000"))
    }
}

time.Since e time.Until

Scorciatoie pratiche per misurare il tempo trascorso e il tempo rimanente prima di un evento:

package main
import ("fmt"; "time")

func benchmark(fn func()) time.Duration {
    start := time.Now()
    fn()
    return time.Since(start)  // = time.Now().Sub(start)
}

func main() {
    d := benchmark(func() { time.Sleep(50 * time.Millisecond) })
    fmt.Printf("took %v\n", d)

    deadline := time.Now().Add(5 * time.Minute)
    fmt.Printf("%.0f minutes remaining\n", time.Until(deadline).Minutes())
}

Fusi orari

Go gestisce i fusi orari con time.Location. Carichi i fusi con time.LoadLocation:

package main
import ("fmt"; "time")

func main() {
    utc := time.Now().UTC()
    fmt.Println(utc)

    loc, err := time.LoadLocation("America/New_York")
    if err != nil { panic(err) }
    nyTime := utc.In(loc)
    fmt.Println(nyTime)

    // Compare times — always in UTC internally
    fmt.Println(utc.Equal(nyTime)) // true — same instant
}

time.Unix — Timestamp Unix

Converta tra time.Time e i timestamp Unix:

package main
import ("fmt"; "time")

func main() {
    now := time.Now()
    unix := now.Unix()            // seconds since epoch
    unixMilli := now.UnixMilli()  // milliseconds
    unixNano := now.UnixNano()    // nanoseconds

    fmt.Println(unix, unixMilli, unixNano)

    // Convert back:
    t := time.Unix(unix, 0)
    fmt.Println(t.Format(time.RFC3339))
}

Verifica rapida

Quale orario di riferimento utilizza Go come modello di formattazione?

Riepilogo: pacchetto time

Riepilogo:

time.Now() — ora corrente; campi tramite .Year(), .Month() e così via
time.Duration — nanosecondi; utilizzi time.Hour, time.Minute e così via
t.Format(layout) / time.Parse(layout, s) — la formattazione utilizza l'orario di riferimento 2006-01-02 15:04:05
time.Since / time.Until per il tempo trascorso o rimanente
time.NewTicker per gli eventi periodici — utilizzi sempre defer Stop()

Domande Frequenti

La lezione «Elementi essenziali del package time» è gratuita?

Sì — il testo completo di «Elementi essenziali del package time» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Elementi essenziali del package time»?

Lavorare con orari, durate e formattazione Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Elementi essenziali del package time»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy