Laikas ir data yra esminiai daugelio programinės įrangos komponentai – nuo laiko valdymo paslaugų iki žiniatinklio programų. Kaip programuotojas, jūs turite žinoti, kaip manipuliuoti laiku ir data bet kuria kalba, kurią naudojate.
„Go“ programoje laikas paketas sujungia laiko ir datos manipuliavimo funkcijas. Šias funkcijas galite pasiekti bet kuriame šaltinio faile, importuodami tą paketą.
Taigi, ką reiškia manipuliuoti laiku ir data ir kaip galite manipuliuoti laiku bei data programoje Go?
Kas yra laiko ir datos manipuliavimas?
Atsižvelgiant į jūsų programos reikalavimus, jai gali tekti valdyti, tvarkyti arba koreguoti laikų ir datų veikimą arba pateikimą.
Įvairios programavimo kalbos turi savo laiko ir datos manipuliavimo funkcijas. Go kalba turi daug galimybių, naudingų šiam tikslui.
Laiko ir datos manipuliavimas gali apimti:
- Dabartinio vietos arba laiko juostos laiko gavimas.
- Aritmetinių operacijų atlikimas laikais ir datomis.
- Laiko ir datos įvesties/išvesties formato keitimas.
Norėdami pradėti manipuliuoti laiku ir data savo Go programose, importuokite
laikas paketą kartu su kitais jūsų naudojamais paketais.importuoti (
"fmt"
"laikas"
)Kaip sužinoti dabartinį laiką ir datą „Go“.
Įprastas laiko manipuliavimo atvejis yra dabartinio vietinio laiko arba konkrečios laiko juostos ar vietos dabartinio laiko gavimas.
Norėdami gauti laiką ir datą savo vietos laiku arba tam tikroje laiko juostoje ar vietoje, galite naudoti laikas. Dabar () ir laikas. Įkėlimo vieta () funkcijos:
func pagrindinis(){
// Gaukite dabartinį laiką ir datą vietos laiku
mano laikas := ime. Dabar ()
fmt. Println("Dabartinis laikas ", Mano laikas. Vieta (), " yra: ", Mano laikas)// Kitas būdas gauti vietos laiką
vieta, _ := laikas. LoadLocation("Vietinis") // arba laikas. LoadLocation("")
fmt. Println("Dabartinis laikas ", vieta, " yra: ", laikas. Dabar().In (vieta))// kita vieta
vieta, _ = laikas. LoadLocation("Amerika/Niujorkas")
fmt. Println("Dabartinis laikas ", vieta, " yra: ", Mano laikas. (vieta))
// gauti dabartinį laiką kalnų laiko juostoje (MST)
vieta, _ = laikas. LoadLocation("MST")
fmt. Println("Dabartinis laikas ", vieta, " yra: ", Mano laikas. (vieta))
}
Paleiskite aukščiau pateiktą programą su eik paleiskite failovardas.go terminale sukuria tokią išvestį:
„LoadLocation“ metodas nepalaiko kiekvienos vietos ir laiko juostos santrumpos. Pagal Eikite į dokumentus, jis palaiko tik vietas, esančias IANA.org duomenų bazė.
Kaip gauti atskirus komponentus nuo nurodytos datos
Galite gauti kiekvieną laiko žymos komponentą atskirai, kuris yra panašus į kada darbas su laiku ir datomis JavaScript.
Yra daug būdų, kaip tai padaryti naudojant Go's laikas funkcijas. Šiame skyriuje parodytas kiekvienas metodas.
Galite naudoti Data() funkcija, skirta dienai, mėnesiui ir metams gauti bei Laikrodis() funkcija, kad gautumėte valandas, minutes ir sekundes. Pavyzdžiui:
funcpagrindinis() {
mano laikas := laikas. Dabar ();
metai, mėnuo, diena := myTime. Data()
fmt. Println("Metai :", metai)
fmt. Println ("mėnuo :", mėnuo)
fmt. Println("Diena:", diena)
valanda, min., sek. := mano laikas. Laikrodis()
fmt. Println("valanda :", valanda)
fmt. Println("Minutė :", min)
fmt. Println("Sekundės :", sek.)
}
Išvestis iliustruoja skirtingas laiko žymos dalis:
Taip pat galite gauti laiko žymos vienetus atskirai naudodami laikas kiekvienos iš jų funkcijos:
funcpagrindinis() {
mano laikas := laikas. Dabar ()
// gauti kiekvieną vienetą nuo metų iki nanosekundės
fmt. Println("Metai:", mano laikas. Metai ()
fmt. Println("Mėnuo:", mano laikas. Mėnuo ())
fmt. Println("Diena:", mano laikas. Diena ())
fmt. Println("Valanda:", mano laikas. valanda ()
fmt. Println("Minutė:", mano laikas. Minutė())
fmt. Println("Sekundės :", mano laikas. Antra())
fmt. Println("Nanosekundė:", mano laikas. Nanosekundė ())
}
Kaip rodo išvestis, tai taip pat suteikia prieigą prie nanosekundžių:
Iki šiol pateikti pavyzdžiai buvo skirti laiko žymos vienetų gavimui iš dabartinio laiko. Tos pačios rūšies veiksmus galite atlikti naudodami laiko žymą, kuri nėra laikas. Dabar ().
Galite išgauti tam tikros datos metus, mėnesį, dieną, valandą, minutę ir sekundę. Norėdami tai padaryti, turite inicijuoti naują datos objektą arba išanalizuoti datą iš eilutės:
funcpagrindinis() {
// gauti atskirus laiko komponentus nuo metų iki nanosekundės
// nuo konkrečios datos
tavo laikas := laikas. Data(2020, 07, 1, 06, 32, 10, 0, laikas. UTC)
fmt. Println("Metai:", jūsų laikas. Metai ()
fmt. Println("Mėnuo:", jūsų laikas. Mėnuo ())
fmt. Println("Diena:", jūsų laikas. Diena ())
fmt. Println("valanda:", jūsų laikas. valanda ()
fmt. Println("Minutė:", jūsų laikas. Minutė())
fmt. Println("Secons:", jūsų laikas. Antra())
fmt. Println("Nanosekundė:", jūsų laikas. Nanosekundė ())
// naudodami funkciją Clock() norėdami gauti valandą, minutę ir sekundę
yourHour, yourMin, yoursec := yourTime. Laikrodis()
fmt. Println ("valanda :", jūsų valanda)
fmt. Println („Minutė :“, jūsų min.)
fmt. Println ("Sekundės :", jūsų sek.)
// gauti laiką ir datą iš eilutės
dateString := "2020-07-0106:32:10"
išdėstymas := "2006-01-0215:04:05" // norimą išvesties formatą
tavo laikas, _ = laikas. Išnagrinėti (išdėstymas, datos eilutė)
fmt. Println ("Jūsų laikas yra: ", jūsų laikas)
fmt. Println("Metai:", jūsų laikas. Metai ()
fmt. Println("Mėnuo:", jūsų laikas. Mėnuo ())
fmt. Println("Diena:", jūsų laikas. Diena ())
fmt. Println("valanda:", jūsų laikas. valanda ()
fmt. Println("Minutė:", jūsų laikas. Minutė())
fmt. Println("Secons:", jūsų laikas. Antra())
}
Šis kodas sukuria tokią išvestį:
Atminkite, kad Parse() naudoja UTC pagal numatytuosius nustatymus, jei nenurodote laiko juostos datos eilutėje.
Kaip atlikti aritmetinius veiksmus su data ir laiku
Aritmetinės operacijos yra dar vienas manipuliavimo tipas, kurį galite atlikti pagal laiką ir datą programoje Go. Galimos paprastos operacijos, tokios kaip sudėjimas, atėmimas ir laiko skirtumas.
Go leidžia apibrėžti laikas. Trukmė vertės su visais laiko vienetais nuo laikas. Valanda į laikas. Nanosekundė. Šias reikšmes galite naudoti norėdami pridėti arba atimti laiką naudodami Papildyti(). Taip pat yra an AddDate () funkcija, kuri paima 3 parametrus: metus, mėnesius ir dienas, kad atliktų sudėjimą arba atimtį.
Šis kodas parodo šių funkcijų naudojimą:
funcpagrindinis() {
curTime := laikas. Dabar ()
curTime = curTime. Pridėti (laikas. valanda) // prideda vieną valandą
fmt. Println("Dabartinis laikas yra: ", curTime)
rytoj := curTime. Pridėti (laikas. valanda* 24)
fmt. Println("Šį kartą rytoj yra: ", rytoj)
nextWeek := curTime. Pridėti (laikas. valanda* 24 * 7)
fmt. Println("Šis laikas kitą savaitę yra: ", kita savaitė)
// naudojant AddDate (y, m, d)
nextTomorrow := curTime. AddDate(0, 0, 2)
fmt. Println("Šį kartą Kitą rytoj yra: ", nextTomorrow)
nextMonth := Curtime. AddDate(0, 1, 0)
fmt. Println("Šis laikas kitą mėnesį yra: ", nextMonth)
fiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
fmt. Println ("Šį kartą po penkerių metų ir vieno mėnesio yra: ", penkerių metų ir vieno mėnesio po)
}
Kuris sukuria tokią produkciją:
Taip pat galite atimti laiką su Papildyti() ir AddDate () perduodant neigiamus parametrus. Pavyzdžiui:
funcpagrindinis() {
curTime := laikas. Dabar ()// atimkite vieną dieną naudodami AddDate ()
vakar := curTime. AddDate(0, 0, -1)
fmt. Println("Šį kartą vakar buvo: ", vakar)
// atimkite vieną mėnesį naudodami Add()
LastMonth := Curtime. Pridėti (laikas. valanda* -24 * 30)
fmt. Println("Šis laikas praeitą mėnesį buvo: ", praėjusį mėnesį)
}
Gamina šią produkciją:
Nors galite naudoti Papildyti() ir AddDate () norėdami rasti skirtumą tarp datų, Go turi a Sub() funkcija, kuri veikia šiek tiek kitaip:
funcpagrindinis() {
curTime = laikas. Dabar ()
praeitis := laikas. Data(2022, laikas. gruodį, 25, 12, 0, 0, 0, laikas. UTC)
skirtumas := praeitis. Sub (curtime)
fmt. Println ("Skirtumas tarp dabarties ir praeities yra: ", skirtumas)
// gauti skirtumą įvairiais vienetais
metų := tarpt(skirt. Valandos () / 24 / 365)
fmt. Println("Metai: ", metai)
mėnesiai := tarpt(skirt. Valandos () / 24 / 30)
fmt. Println("mėnesiai: ", mėnesiai)
dienos := tarpt(skirt. Valandos () / 24)
fmt. Println("Dienos: ", dienos)
valandos := tarpt(skirt. Valandos ()
fmt. Println("Valandos: ", valandos)
// Skirt. Minutės (), skirtumas. Sekundės (), skirtumas. Milisekundės (), skirtumas. Nanosekundės () taip pat grąžina savo vienetus
}
Šis kodas sukuria tokią išvestį:
Kaip sužinoti laiką ir datą įvairiais formatais
Taip pat galite gauti laiko ir datos išvestis keliais formatais naudodami Formatas () funkcija. Štai keli įprasti formatavimo stiliai:
funcpagrindinis() {
curTime = laikas. Dabar ()
// integruoti standartiniai formatavimo stiliai
fmt. Println("Dabartinis laikas yra: ", curTime)
fmt. Println("Dabartinis laikas RFC3339 formatu yra: ", curTime. Formatas (laikas. RFC3339))
fmt. Println("Dabartinis laikas RFC3339Nano formatu yra: ", curTime. Formatas (laikas. RFC3339Nano))
fmt. Println("Dabartinis laikas RFC1123 formatu yra: ", curTime. Formatas (laikas. RFC1123))
fmt. Println("Dabartinis laikas RFC1123Z formatu yra: ", curTime. Formatas (laikas. RFC1123Z))
fmt. Println("Dabartinis laikas RFC822 formatu yra: ", curTime. Formatas (laikas. RFC822))
fmt. Println("Dabartinis laikas RFC822Z formatu yra: ", curTime. Formatas (laikas. RFC822Z))
fmt. Println("Dabartinis laikas RFC850 formatu yra: ", curTime. Formatas (laikas. RFC850))
fmt. Println("Dabartinis laikas ANSIC formatu yra: ", curTime. Formatas (laikas. ANSIC))
fmt. Println("Dabartinis laikas Unix formatu yra: ", curTime. Formatas (laikas. UnixDate))
// pasirinktiniai formatavimo stiliai
// DD-MM-MMMM HH: MM: SS
fmt. Println("Dabartinis laikas pasirinktiniame formate yra: ", curTime. Formatas ("02-01-200615:04:05"))
// MM-DD-YYYY HH: MM: SS
fmt. Println("Dabartinis laikas pasirinktiniame formate yra: ", curTime. Formatas ("01-02-200615:04:05"))
// YYYY-MM-DD HH: MM: SS
fmt. Println("Dabartinis laikas pasirinktiniame formate yra: ", curTime. Formatas ("2006-01-0215:04:05"))
// DD.MM.YYYY
fmt. Println("Dabartinis laikas pasirinktiniame formate yra: ", curTime. Formatas ("02.01.2006"))
// DD/MM/MMMM
fmt. Println("Dabartinis laikas pasirinktiniame formate yra: ", curTime. Formatas ("02/01/2006"))
// 2006 m. vasario 1 d
fmt. Println("Dabartinis laikas pasirinktiniame formate yra: ", curTime. Formatas ("02 sausio mėn 2006"))
// 2006 m. vasario 1 d. Pirmadienis
fmt. Println("Dabartinis laikas pasirinktiniame formate yra: ", curTime. Formatas ("02 vasario mėn 2006 pirmadienis"))
// 2006 m. vasario 1 d., pirmadienis, 15:04:05
fmt. Println("Dabartinis laikas pasirinktiniame formate yra: ", curTime. Formatas ("02 vasario mėn 2006 Pirm 15:04:05"))
}
Šie skirtingi formatavimo tipai sukuria tokią išvestį:
Laiko ir datos manipuliavimas eidami
Manipuliacijų, kurias galite atlikti tam tikru laiku ir datomis, sąrašas yra beveik nesibaigiantis. Atsižvelgiant į taikymo sritį, gali tekti atlikti daug įvairių datos ir laiko operacijų.
Bet kokiu atveju, jei turite, laikas paketas yra labai funkcionalus ir turi daug integruotų metodų.
Galite naudoti manipuliavimą data ir laiku, kad sukurtumėte paprastą dienos planavimo arba užduočių planavimo programą.
