Ora și data sunt componente esențiale ale multor programe software, de la utilitare de gestionare a timpului până la aplicații web. Ca programator, trebuie să știi cum să manipulezi ora și data în orice limbă pe care o folosești.
În Go, timp pachetul include funcțiile pentru manipularea orei și datei. Puteți accesa aceste funcții în orice fișier sursă importând acel pachet.
Deci, ce înseamnă să manipulați ora și data și cum puteți manipula ora și data în Go?
Ce este manipularea orei și datei?
În funcție de cerințele programului dvs., poate fi necesar să controleze, să gestioneze sau să ajusteze comportamentul sau reprezentarea orelor și a datelor.
Diferite limbaje de programare au propriile funcții pentru manipularea orei și datei. Limbajul Go are capabilități extinse, utile în acest scop.
Manipularea orei și datei poate include:
- Obținerea orei curente a unei locații sau fus orar.
- Efectuarea de operații aritmetice pe ore și date.
- Modificarea formatului de intrare/ieșire al orelor și datelor.
Pentru a începe să manipulați ora și data în aplicațiile Go, importați fișierul timp pachet alături de celelalte pachete pe care le utilizați.
import (
"fmt"
"timp"
)Cum să obțineți ora și data curente în Go
Un caz comun de utilizare pentru manipularea orei este obținerea orei locale curente sau a orei curente a unui anumit fus orar sau locație.
Pentru a obține ora și data la ora locală sau într-un anumit fus orar sau locație, puteți utiliza timp. Acum() și timp. LoadLocation() functii:
func principal(){
// Obține ora și data curente în Ora locală
myTime := ime. Acum()
fmt. Println("Ora curentă în ", timpul meu. Locație(), " este: ", timpul meu)// O altă modalitate de a obține ora locală
locație, _ := timp. LoadLocation("Local") // sau timp. LoadLocation("")
fmt. Println("Ora curentă în ", Locație, " este: ", timp. Acum().În (locație))// altă locație
locație, _ = timp. LoadLocation("America/New_York")
fmt. Println("Ora curentă în ", Locație, " este: ", timpul meu. În (locație))
// obțineți ora curentă în fusul orar de munte (MST)
locație, _ = timp. LoadLocation("MST")
fmt. Println("Ora curentă în ", Locație, " este: ", timpul meu. În (locație))
}
Rularea programului de mai sus cu mergeți să rulați filename.go produce următoarea ieșire în terminal:
Metoda LoadLocation nu acceptă fiecare abreviere de locație și fus orar. In conformitate cu Du-te la documentare, acceptă doar locații din baza de date IANA.org.
Cum să obțineți componente separate de la o dată dată
Puteți obține fiecare componentă a marcajului de timp separat, care este similar cu când lucrul cu ora și datele în JavaScript.
Există numeroase moduri de a realiza acest lucru folosind Go's timp funcții. Această secțiune ilustrează fiecare metodă.
Puteți folosi Data() funcția pentru a obține ziua, luna și anul și Ceas() funcția pentru a obține ora, minutul și secundele. De exemplu:
funcprincipal() {
myTime := timp. Acum();
an, lună, zi := myTime. Data()
fmt. Println("Anul :", an)
fmt. Println("Luna :", luna)
fmt. Println(„Ziua :”, zi)
oră, min, sec := myTime. Ceas()
fmt. Println("Ora :", ora)
fmt. Println("Minut :", min)
fmt. Println("Secunde :", sec)
}
Ieșirea ilustrează diferitele părți ale marcajului de timp:
De asemenea, puteți obține unități ale marcajului de timp individual cu ajutorul timp funcții pentru fiecare dintre ele:
funcprincipal() {
myTime := timp. Acum()
// obțineți fiecare unitate de la An la Nanosecundă
fmt. Println("Anul :", ora mea. An())
fmt. Println("Luna :", ora mea. Lună())
fmt. Println("Ziua :", ora mea. Zi())
fmt. Println("Ora :", ora mea. Ora())
fmt. Println("Minutul :", ora mea. Minut())
fmt. Println("Secunde :", ora mea. Al doilea())
fmt. Println("Nanosecundă :", myTime. Nanosecundă())
}
După cum ilustrează rezultatul, acest lucru vă oferă și acces la nanosecunde:
Exemplele de până la acest punct s-au concentrat pe obținerea de unități de marcaj de timp din timpul curent. Puteți efectua aceleași tipuri de acțiuni pe un marcaj de timp care nu este timp. Acum().
Puteți extrage anul, luna, ziua, ora, minutul și secunda unei date date. Pentru a face acest lucru, trebuie fie să inițializați un nou obiect dată, fie să analizați data dintr-un șir:
funcprincipal() {
// obțineți componente individuale ale timpului de la An la Nanosecundă
// de la o anumită dată
yourTime := timp. Data(2020, 07, 1, 06, 32, 10, 0, timp. UTC)
fmt. Println("Anul :", ora ta. An())
fmt. Println("Luna :", ora ta. Lună())
fmt. Println("Ziua :", ora ta. Zi())
fmt. Println("Ora :", ora ta. Ora())
fmt. Println("Minutul :", ora ta. Minut())
fmt. Println("Secunde :", ora ta. Al doilea())
fmt. Println("Nanosecundă :", Ora ta. Nanosecundă())
// folosind funcția Clock() pentru a obține ora, minutul și secunda
yourHour, yourMin, yourSec := yourTime. Ceas()
fmt. Println("Ora :", ora ta)
fmt. Println("Minutul :", min. tau)
fmt. Println("Secunde :", secunda ta)
// obține ora și data din șir
dateString := "2020-07-0106:32:10"
aspect := "2006-01-0215:04:05" // formatul de ieșire dorit
yourTime, _ = timp. Parse (aspect, dateString)
fmt. Println("Ora ta este: ", Ora ta)
fmt. Println("Anul :", ora ta. An())
fmt. Println("Luna :", ora ta. Lună())
fmt. Println("Ziua :", ora ta. Zi())
fmt. Println("Ora :", ora ta. Ora())
fmt. Println("Minutul :", ora ta. Minut())
fmt. Println("Secunde :", ora ta. Al doilea())
}
Acest cod produce următoarea ieșire:
Rețineți că Parse() folosește UTC implicit dacă nu specificați un fus orar în șirul de date.
Cum se efectuează operații aritmetice cu data și ora
Operațiile aritmetice sunt un alt tip de manipulare pe care o puteți efectua la ora și data în Go. Sunt posibile operațiuni simple precum adunarea, scăderea și diferența de timp.
Go vă permite să definiți timp. Durată valori cu toate unitățile de timp de la timp. Ora la timp. Nanosecundă. Puteți folosi aceste valori pentru a adăuga sau scădea timp folosind Adăuga(). Există și o AddDate() funcție care ia în 3 parametri: ani, luni și zile pentru efectuarea adunării sau scăderii.
Următorul cod demonstrează utilizarea acestor funcții:
funcprincipal() {
curTime := timp. Acum()
curTime = curTime. Adăugați (ora. Ora) // adaugă o oră
fmt. Println("Ora curentă este: ", curTime)
maine := curTime. Adăugați (ora. Ora * 24)
fmt. Println("La această oră mâine este: ", mâine)
săptămâna viitoare := curTime. Adăugați (ora. Ora * 24 * 7)
fmt. Println("De data aceasta săptămâna viitoare este: ", săptămâna viitoare)
// folosind AddDate (y, m, d)
următorMâine := curTime. AdaugaData(0, 0, 2)
fmt. Println("De data aceasta Mâine este: ", Mâine următor)
nextMonth := curTime. AdaugaData(0, 1, 0)
fmt. Println("De data aceasta luna viitoare este: ", lună următoare)
fiveYearsAndOneMonthAfter := curTime. AdaugaData(5, 1, 0)
fmt. Println("De data aceasta cinci ani și o lună după este: ", cinci ani și o lună după)
}
Care produce următoarea ieșire:
De asemenea, puteți scădea timpul cu Adăuga() și AddDate() prin trecerea parametrilor negativi. De exemplu:
funcprincipal() {
curTime := timp. Acum()// scade o zi folosind AddDate()
ieri := curTime. AdaugaData(0, 0, -1)
fmt. Println("De data aceasta ieri a fost: ", ieri)
// scade o lună folosind Add()
lastMonth := curTime. Adăugați (ora. Ora * -24 * 30)
fmt. Println("De data aceasta luna trecută a fost: ", ultima lună)
}
Produce această ieșire:
Deși poți folosi Adăuga() și AddDate() pentru a găsi distincția între date, Go are a Sub() funcție care funcționează puțin diferit:
funcprincipal() {
curTime = timp. Acum()
trecut := timp. Data(2022, timp. Decembrie, 25, 12, 0, 0, 0, timp. UTC)
diff := trecut. Sub (curTime)
fmt. Println("Diferența dintre acum și trecut este: ", dif.)
// obțineți diferența în diferite unități
ani := int(dif. Ore() / 24 / 365)
fmt. Println("Ani: ", ani)
luni := int(dif. Ore() / 24 / 30)
fmt. Println("Luni: ", luni)
zile := int(dif. Ore() / 24)
fmt. Println("Zile: ", zile)
ore := int(dif. Ore())
fmt. Println("Ore: ", ore)
// dif. Minute(), dif. Secunde(), dif. Milisecunde(), dif. Nanoseconds() returnează și unitățile lor
}
Acest cod produce următoarea ieșire:
Cum să obțineți ora și data în diferite formate
De asemenea, puteți obține date și oră în mai multe formate folosind Format() funcţie. Iată câteva stiluri comune de formatare:
funcprincipal() {
curTime = timp. Acum()
// stiluri de formatare standard încorporate
fmt. Println("Ora curentă este: ", curTime)
fmt. Println("Ora curentă în format RFC3339 este: ", curTime. Format (timp. RFC3339))
fmt. Println("Ora curentă în formatul RFC3339Nano este: ", curTime. Format (timp. RFC3339Nano))
fmt. Println("Ora curentă în format RFC1123 este: ", curTime. Format (timp. RFC1123))
fmt. Println("Ora curentă în format RFC1123Z este: ", curTime. Format (timp. RFC1123Z))
fmt. Println("Ora curentă în format RFC822 este: ", curTime. Format (timp. RFC822))
fmt. Println("Ora curentă în formatul RFC822Z este: ", curTime. Format (timp. RFC822Z))
fmt. Println("Ora curentă în format RFC850 este: ", curTime. Format (timp. RFC850))
fmt. Println("Ora curentă în format ANSIC este: ", curTime. Format (timp. ANSIC))
fmt. Println("Ora curentă în format Unix este: ", curTime. Format (timp. UnixDate))
// stiluri de formatare personalizate
// ZZ-LL-AAAA HH: LL: SS
fmt. Println("Ora curentă în format personalizat este: ", curTime. Format("02-01-200615:04:05"))
// LL-ZZ-AAAA HH: LL: SS
fmt. Println("Ora curentă în format personalizat este: ", curTime. Format("01-02-200615:04:05"))
// AAAA-LL-ZZ HH: LL: SS
fmt. Println("Ora curentă în format personalizat este: ", curTime. Format("2006-01-0215:04:05"))
// ZZ.LL.AAAA
fmt. Println("Ora curentă în format personalizat este: ", curTime. Format("02.01.2006"))
// ZZ/LL/AAAA
fmt. Println("Ora curentă în format personalizat este: ", curTime. Format("02/01/2006"))
// 01 februarie 2006
fmt. Println("Ora curentă în format personalizat este: ", curTime. Format("02 ian 2006"))
// 01 februarie 2006 luni
fmt. Println("Ora curentă în format personalizat este: ", curTime. Format("02 februarie 2006 Luni"))
// 01 februarie 2006 Luni 15:04:05
fmt. Println("Ora curentă în format personalizat este: ", curTime. Format("02 februarie 2006 Lun 15:04:05"))
}
Aceste tipuri diferite de formatare produc următoarele rezultate:
Manipularea orei și datei în Go
Lista manipulărilor pe care le puteți efectua la ore și date este aproape nesfârșită. În funcție de domeniul de aplicare al aplicației dvs., este posibil să fie necesar să efectuați multe operațiuni diferite de dată/ora.
Pentru orice caz de utilizare pe care îl aveți, timp pachetul este foarte funcțional și are multe metode încorporate.
Puteți utiliza manipularea datei și orei pentru a crea un planificator zilnic simplu sau o aplicație de planificare a sarcinilor.