L'ora e la data sono componenti cruciali di molti software, dalle utilità di gestione del tempo alle applicazioni web. Come programmatore, devi sapere come manipolare l'ora e la data in qualsiasi lingua usi.
In Vai, il volta il pacchetto raggruppa le funzioni per la manipolazione dell'ora e della data. Puoi accedere a queste funzioni in qualsiasi file sorgente importando quel pacchetto.
Quindi, cosa significa manipolare l'ora e la data e come puoi manipolare l'ora e la data in Go?
Che cos'è la manipolazione di ora e data?
In base ai requisiti del tuo programma, potrebbe essere necessario controllare, gestire o regolare il comportamento o la rappresentazione di orari e date.
Linguaggi di programmazione diversi hanno le proprie funzioni per la manipolazione dell'ora e della data. Il linguaggio Go ha capacità estese, utili a questo scopo.
La manipolazione di ora e data può includere:
- Ottenere l'ora corrente di una posizione o fuso orario.
- Esecuzione di operazioni aritmetiche su orari e date.
- Modifica del formato di input/output di orari e date.
Per iniziare a manipolare l'ora e la data nelle tue applicazioni Go, importa il file volta pacchetto insieme agli altri pacchetti che stai utilizzando.
importare (
"fmt"
"volta"
)Come ottenere l'ora e la data correnti in Go
Un caso d'uso comune per la manipolazione dell'ora è ottenere l'ora locale corrente o l'ora corrente di un fuso orario o luogo specifico.
Per ottenere l'ora e la data nella tua ora locale o in un fuso orario o in una posizione specifica, puoi utilizzare il volta. Adesso() e volta. Posizione di carico() funzioni:
funz principale(){
// Ottieni l'ora e la data correnti in Ora locale
myTime := io. Adesso()
fmt. Stampaln("Ora attuale ", mio tempo. Posizione(), " è: ", mio tempo)// Un altro modo per ottenere l'ora locale
luogo, _ := ora. Posizione di carico("Locale") // o ora. Posizione di carico("")
fmt. Stampaln("Ora attuale ", Posizione, " è: ", volta. Now().In (posizione))// un'altra posizione
luogo, _ = ora. Posizione di carico("America/New_York")
fmt. Stampaln("Ora attuale ", Posizione, " è: ", mio tempo. In (posizione))
// ottieni l'ora corrente in Mountain Time Zone (MST)
luogo, _ = ora. Posizione di carico("MST")
fmt. Stampaln("Ora attuale ", Posizione, " è: ", mio tempo. In (posizione))
}
Eseguire il programma sopra con vai a eseguire filename.go produce il seguente output nel terminale:
Il metodo LoadLocation non supporta tutte le abbreviazioni di località e fuso orario. Secondo il Vai alla documentazione, supporta solo posizioni in Banca dati IANA.org.
Come ottenere componenti separati da una data determinata
Puoi ottenere ogni componente del timestamp separatamente, che è simile a quando lavorare con l'ora e le date in JavaScript.
Ci sono molti modi per farlo usando Go's volta funzioni. Questa sezione illustra ciascun metodo.
Puoi usare il Data() funzione per ottenere il giorno, il mese e l'anno e il Orologio() funzione per ottenere l'ora, i minuti e i secondi. Per esempio:
funzprincipale() {
miaOra := ora. Adesso();
anno, mese, giorno := myTime. Data()
fmt. Println("Anno :", anno)
fmt. Println("Mese :", mese)
fmt. Println("Giorno :", giorno)
ora, min, sec := myTime. Orologio()
fmt. Println("Ora :", ora)
fmt. Println("Minuto :", min)
fmt. Println("Secondi :", sec)
}
L'output illustra le diverse parti del timestamp:
Puoi anche ottenere unità del timestamp individualmente con il volta funzioni per ciascuno di essi:
funzprincipale() {
miaOra := ora. Adesso()
// ottiene ogni unità da Anno a Nanosecondo
fmt. Println("Anno :", myTime. Anno())
fmt. Println("Mese :", myTime. Mese())
fmt. Println("Giorno :", myTime. Giorno())
fmt. Println("Ora :", myTime. Ora())
fmt. Println("Minuto :", myTime. Minuto())
fmt. Println("Secondi :", myTime. Secondo())
fmt. Println("Nanosecondo :", myTime. Nanosecondo())
}
Come illustra l'output, questo ti dà anche accesso ai nanosecondi:
Gli esempi fino a questo punto si sono concentrati sull'ottenimento di unità timestamp dall'ora corrente. Puoi eseguire lo stesso tipo di azione su un timestamp che non lo è volta. Adesso().
È possibile estrarre l'anno, il mese, il giorno, l'ora, i minuti ei secondi di una determinata data. Per fare ciò, devi inizializzare un nuovo oggetto data o analizzare la data da una stringa:
funzprincipale() {
// ottiene i singoli componenti del tempo da Anno a Nanosecondo
// da una data specifica
il tuo Tempo := tempo. Data(2020, 07, 1, 06, 32, 10, 0, volta. UTC)
fmt. Println("Anno :", la tuaOra. Anno())
fmt. Println("Mese :", il tuoOra. Mese())
fmt. Println("Giorno :", il tuoOra. Giorno())
fmt. Println("Ora :", il tuoOra. Ora())
fmt. Println("Minuto :", il tuo Tempo. Minuto())
fmt. Println("Secondi:", il tuo Tempo. Secondo())
fmt. Println("Nanosecondo :", il tuo Tempo. Nanosecondo())
// usando la funzione Clock() per ottenere ore, minuti e secondi
yourHour, yourMin, yourSec := yourTime. Orologio()
fmt. Println("Ora :", la tuaOra)
fmt. Println("Minuto :", tuoMin)
fmt. Println("Secondi :", tuoSec)
// ottiene l'ora e la data dalla stringa
dataString := "2020-07-0106:32:10"
disposizione := "2006-01-0215:04:05" // il formato di output desiderato
il tuo Tempo, _ = tempo. Analizza (layout, dateString)
fmt. Println("La tua ora è: ", la tua ora)
fmt. Println("Anno :", la tuaOra. Anno())
fmt. Println("Mese :", il tuoOra. Mese())
fmt. Println("Giorno :", il tuoOra. Giorno())
fmt. Println("Ora :", il tuoOra. Ora())
fmt. Println("Minuto :", il tuo Tempo. Minuto())
fmt. Println("Secondi:", il tuo Tempo. Secondo())
}
Questo codice produce il seguente output:
Nota che utilizza Parse() UTC per impostazione predefinita se non si specifica un fuso orario nella stringa della data.
Come eseguire operazioni aritmetiche con data e ora
Le operazioni aritmetiche sono un altro tipo di manipolazione che puoi eseguire su ora e data in Go. Sono tutte possibili operazioni semplici come addizione, sottrazione e differenza di tempo.
Vai ti permette di definire volta. Durata valori con tutte le unità di tempo da volta. Ora a volta. Nanosecondo. È possibile utilizzare questi valori per aggiungere o sottrarre tempo utilizzando Aggiungere(). C'è anche un Aggiungi data() funzione che accetta 3 parametri: anni, mesi e giorni per eseguire addizioni o sottrazioni.
Il codice seguente mostra l'uso di queste funzioni:
funzprincipale() {
curTime := tempo. Adesso()
curTime = curTime. Aggiungi (tempo. Ora) // aggiunge un'ora
fmt. Println("L'ora corrente è: ", curTime)
domani := curTime. Aggiungi (tempo. Ora * 24)
fmt. Println("Questa volta domani è: ", domani)
nextWeek := curTime. Aggiungi (tempo. Ora * 24 * 7)
fmt. Println("Questa volta la prossima settimana è: ", nextWeek)
// usando AddDate (y, m, d)
nextTomorrow := curTime. AddDate(0, 0, 2)
fmt. Println("Questa volta il prossimo domani è: ", nextTomorrow)
mese successivo := curTime. AddDate(0, 1, 0)
fmt. Println("Questa volta il prossimo mese è: ", nextMonth)
fiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
fmt. Println("Questa volta cinque anni e un mese dopo è: ", fiveYearsAndOneMonthAfter)
}
Che produce il seguente output:
Puoi anche sottrarre il tempo con Aggiungere() e Aggiungi data() passando parametri negativi. Per esempio:
funzprincipale() {
curTime := tempo. Adesso()// sottrai un giorno usando AddDate()
ieri := curTime. AddDate(0, 0, -1)
fmt. Println("Questa volta ieri era: ", ieri)
// sottrai un mese usando Add()
ultimo mese := curTime. Aggiungi (tempo. Ora * -24 * 30)
fmt. Println("Questa volta il mese scorso era: ", lastMonth)
}
Produce questo output:
Anche se puoi usare Aggiungere() e Aggiungi data() per trovare la distinzione tra le date, Go ha a Sub() funzione che funziona in modo leggermente diverso:
funzprincipale() {
curTime = tempo. Adesso()
passato := tempo. Data(2022, volta. Dicembre, 25, 12, 0, 0, 0, volta. UTC)
diff := passato. Sub (curTime)
fmt. Println("La differenza tra ora e il passato è: ", diff)
// ottieni la differenza in varie unità
anni := int(diff. Ore() / 24 / 365)
fmt. Println("Anni: ", anni)
mesi := int(diff. Ore() / 24 / 30)
fmt. Println("Mesi: ", mesi)
giorni := int(diff. Ore() / 24)
fmt. Println("Giorni: ", giorni)
ore := int(diff. Ore())
fmt. Println("Ore: ", ore)
// diff. Minuti(), diff. Secondi(), diff. Millisecondi(), diff. Nanoseconds() restituisce anche le loro unità
}
Questo codice produce il seguente output:
Come ottenere l'ora e la data in vari formati
Puoi anche ottenere output di data e ora in più formati usando il file Formato() funzione. Ecco alcuni stili di formattazione comuni:
funzprincipale() {
curTime = tempo. Adesso()
// stili di formattazione standard incorporati
fmt. Println("L'ora corrente è: ", curTime)
fmt. Println("L'ora corrente nel formato RFC3339 è: ", curTime. Formato (ora. RFC3339))
fmt. Println("L'ora corrente nel formato RFC3339Nano è: ", curTime. Formato (ora. RFC3339Nano))
fmt. Println("L'ora corrente nel formato RFC1123 è: ", curTime. Formato (ora. RFC1123))
fmt. Println("L'ora corrente nel formato RFC1123Z è: ", curTime. Formato (ora. RFC1123Z))
fmt. Println("L'ora corrente nel formato RFC822 è: ", curTime. Formato (ora. RFC822))
fmt. Println("L'ora corrente nel formato RFC822Z è: ", curTime. Formato (ora. RFC822Z))
fmt. Println("L'ora corrente nel formato RFC850 è: ", curTime. Formato (ora. RFC850))
fmt. Println("L'ora corrente in formato ANSIC è: ", curTime. Formato (ora. ANSIC))
fmt. Println("L'ora corrente nel formato Unix è: ", curTime. Formato (ora. Data Unix))
// stili di formattazione personalizzati
// GG-MM-AAAA HH: MM: SS
fmt. Println("L'ora corrente nel formato personalizzato è: ", curTime. Formato("02-01-200615:04:05"))
// MM-GG-AAAA HH: MM: SS
fmt. Println("L'ora corrente nel formato personalizzato è: ", curTime. Formato("01-02-200615:04:05"))
// AAAA-MM-GG HH: MM: SS
fmt. Println("L'ora corrente nel formato personalizzato è: ", curTime. Formato("2006-01-0215:04:05"))
// GG.MM.AAAA
fmt. Println("L'ora corrente nel formato personalizzato è: ", curTime. Formato("02.01.2006"))
// GG/MM/AAAA
fmt. Println("L'ora corrente nel formato personalizzato è: ", curTime. Formato("02/01/2006"))
// 01 febbraio 2006
fmt. Println("L'ora corrente nel formato personalizzato è: ", curTime. Formato("02 gen 2006"))
// 01 febbraio 2006 lunedì
fmt. Println("L'ora corrente nel formato personalizzato è: ", curTime. Formato("02 febbraio 2006 Lunedi"))
// 01 febbraio 2006 lun 15:04:05
fmt. Println("L'ora corrente nel formato personalizzato è: ", curTime. Formato("02 febbraio 2006 lun 15:04:05"))
}
Questi diversi tipi di formattazione producono il seguente output:
Manipolazione di ora e data in Go
L'elenco delle manipolazioni che puoi eseguire su orari e date è quasi infinito. A seconda dell'ambito dell'applicazione, potrebbe essere necessario eseguire molte diverse operazioni di data/ora.
Per ogni caso d'uso che potresti avere, il volta il pacchetto è molto funzionale e ha molti metodi integrati.
È possibile utilizzare la manipolazione di data e ora per creare una semplice app di pianificazione giornaliera o di pianificazione delle attività.
