Laiks un datums ir ļoti svarīgas daudzas programmatūras sastāvdaļas, sākot no laika pārvaldības utilītprogrammām līdz tīmekļa lietojumprogrammām. Kā programmētājam jums ir jāzina, kā manipulēt ar laiku un datumu jebkurā valodā, kuru izmantojat.
Programmā Go, laiks pakotne apvieno funkcijas laika un datuma manipulācijām. Varat piekļūt šīm funkcijām jebkurā avota failā, importējot šo pakotni.
Tātad, ko nozīmē manipulēt ar laiku un datumu, un kā jūs varat manipulēt ar laiku un datumu programmā Go?
Kas ir laika un datuma manipulācija?
Saskaņā ar jūsu programmas prasībām tai var būt nepieciešams kontrolēt, pārvaldīt vai pielāgot darbību vai laiku un datumu attēlojumu.
Dažādas programmēšanas valodas ir savas funkcijas laika un datuma manipulēšanai. Go valodai ir plašas iespējas, kas ir noderīgas šim nolūkam.
Laika un datuma manipulācijas var ietvert:
- Atrašanās vietas vai laika joslas pašreizējā laika iegūšana.
- Aritmētisko darbību veikšana ar laikiem un datumiem.
- Laiku un datumu ievades/izvades formāta maiņa.
Lai Go lietojumprogrammās sāktu manipulēt ar laiku un datumu, importējiet laiks paketi kopā ar citiem jūsu izmantotajiem iepakojumiem.
imports (
"fmt"
"laiks"
)Kā uzzināt pašreizējo laiku un datumu Go
Parasti laika manipulācijām tiek izmantota pašreizējā vietējā laika vai konkrētas laika joslas vai vietas pašreizējā laika iegūšana.
Lai iegūtu laiku un datumu pēc vietējā laika vai noteiktā laika joslā vai atrašanās vietā, varat izmantot laiks. Tagad () un laiks. LoadLocation() funkcijas:
func galvenais(){
// Iegūstiet pašreizējo laiku un datumu pēc vietējā laika
myTime := ime. Tagad ()
fmt. Println("Pašreizējais laiks iekšā ", Mans laiks. Atrašanās vieta (), " ir: ", Mans laiks)// Vēl viens veids, kā iegūt vietējo laiku
vieta, _ := laiks. LoadLocation("Vietējais") // vai laiks. LoadLocation("")
fmt. Println("Pašreizējais laiks iekšā ", atrašanās vieta, " ir: ", laiks. Tagad().In (atrašanās vieta))// cita vieta
vieta, _ = laiks. LoadLocation("Amerika/Ņujorka")
fmt. Println("Pašreizējais laiks iekšā ", atrašanās vieta, " ir: ", Mans laiks. Vietnē (atrašanās vieta))
// iegūt pašreizējo laiku kalnu laika joslā (MST)
vieta, _ = laiks. LoadLocation("MST")
fmt. Println("Pašreizējais laiks iekšā ", atrašanās vieta, " ir: ", Mans laiks. Vietnē (atrašanās vieta))
}
Palaižot iepriekš minēto programmu ar palaist filename.go terminālā rada šādu izvadi:
LoadLocation metode neatbalsta visas atrašanās vietas un laika joslas saīsinājumus. Saskaņā ar Dodieties uz dokumentāciju, tas atbalsta tikai atrašanās vietas IANA.org datu bāze.
Kā iegūt atsevišķas sastāvdaļas noteiktā datumā
Katru laikspiedola komponentu var iegūt atsevišķi, kas ir līdzīgs tam, kad darbs ar laiku un datumiem JavaScript.
Ir daudz veidu, kā to paveikt, izmantojot Go's laiks funkcijas. Šī sadaļa ilustrē katru metodi.
Jūs varat izmantot Datums() funkcija, lai iegūtu dienu, mēnesi un gadu, un Pulkstenis () funkcija, lai iegūtu stundu, minūti un sekundes. Piemēram:
funcgalvenais() {
myTime := laiks. Tagad ();
gads, mēnesis, diena := myTime. Datums()
fmt. Println("Gads :", gads)
fmt. Println("Mēnesis :", mēnesis)
fmt. Println("Diena :", diena)
stunda, min, sek := myTime. Pulkstenis ()
fmt. Println("stunda :", stunda)
fmt. Println("Minūte :", min)
fmt. Println("Sekundes :", sek)
}
Izvade ilustrē dažādas laikspiedola daļas:
Varat arī iegūt laika zīmoga vienības atsevišķi, izmantojot laiks funkcijas katrai no tām:
funcgalvenais() {
myTime := laiks. Tagad ()
// iegūt katru vienību no gada līdz nanosekundei
fmt. Println("Gads:", mans laiks. Gads())
fmt. Println("Mēnesis:", mans laiks. Mēnesis())
fmt. Println("Diena:", mans laiks. diena())
fmt. Println("stunda:", mans laiks. Stunda())
fmt. Println("Minūte:", myTime. Minūte ()
fmt. Println("Sekundes:", myTime. Otrais())
fmt. Println ("Nanosekunde:", mans laiks. Nanosekunde())
}
Kā parāda izvade, tas arī nodrošina piekļuvi nanosekundēm:
Piemēri līdz šim ir vērsti uz laikspiedolu vienību iegūšanu no pašreizējā laika. Jūs varat veikt tādas pašas darbības ar laikspiedolu, kas nav laiks. Tagad ().
Varat izvilkt noteiktā datuma gadu, mēnesi, dienu, stundu, minūti un sekundi. Lai to izdarītu, jums ir vai nu jāinicializē jauns datuma objekts, vai jāparsē datums no virknes:
funcgalvenais() {
// iegūt atsevišķus laika komponentus no gada līdz nanosekundei
// no konkrēta datuma
yourTime := laiks. Datums(2020, 07, 1, 06, 32, 10, 0, laiks. UTC)
fmt. Println("Gads :", jūsu laiks. Gads())
fmt. Println("Mēnesis:", jūsu laiks. Mēnesis())
fmt. Println("Diena:", jūsu laiks. diena())
fmt. Println("stunda:", jūsu laiks. Stunda())
fmt. Println("Minūte:", jūsu laiks. Minūte ()
fmt. Println("Sekundes:", jūsu laiks. Otrais())
fmt. Println("Nanosekunde:", jūsu laiks. Nanosekunde())
// izmantojot funkciju Clock(), lai iegūtu stundu, minūti un sekundi
yourHour, yourMin, yourSec := yourTime. Pulkstenis ()
fmt. Println ("stunda :", jūsu stunda)
fmt. Println ("Minūte :", jūsu Min)
fmt. Println ("Sekundes :", jūsu sek.)
// iegūt laiku un datumu no virknes
dateString := "2020-07-0106:32:10"
izkārtojums := "2006-01-0215:04:05" // vēlamo izvades formātu
yourTime, _ = laiks. Parsēt (izkārtojums, datuma virkne)
fmt. Println("Tavs laiks ir: ", tavs laiks)
fmt. Println("Gads :", jūsu laiks. Gads())
fmt. Println("Mēnesis:", jūsu laiks. Mēnesis())
fmt. Println("Diena:", jūsu laiks. diena())
fmt. Println("stunda:", jūsu laiks. Stunda())
fmt. Println("Minūte:", jūsu laiks. Minūte ()
fmt. Println("Sekundes:", jūsu laiks. Otrais())
}
Šis kods rada šādu izvadi:
Ņemiet vērā, ka Parse () izmanto UTC pēc noklusējuma, ja datuma virknē nenorāda laika joslu.
Kā veikt aritmētiskās darbības ar datumu un laiku
Aritmētiskās darbības ir vēl viens manipulāciju veids, ko varat veikt laikā un datumā programmā Go. Ir iespējamas vienkāršas darbības, piemēram, saskaitīšana, atņemšana un laika starpība.
Go ļauj definēt laiks. Ilgums vērtības ar visām laika vienībām no laiks. Stunda uz laiks. Nanosekunde. Varat izmantot šīs vērtības, lai pievienotu vai atņemtu laiku, izmantojot Pievienot (). Ir arī an Pievienošanas datums() funkcija, kas aizņem 3 parametrus: gadi, mēneši un dienas, lai veiktu saskaitīšanu vai atņemšanu.
Šis kods parāda šo funkciju izmantošanu:
funcgalvenais() {
curTime := laiks. Tagad ()
curTime = curTime. Pievienot (laiks. Stunda) // pievieno vienu stundu
fmt. Println("Pašreizējais laiks ir: ", curTime)
rīt := curTime. Pievienot (laiks. Stunda * 24)
fmt. Println("Šoreiz rīt ir: ", rīt)
nextWeek := curTime. Pievienot (laiks. Stunda * 24 * 7)
fmt. Println("Šis laiks nākamnedēļ ir: ", nākamnedēļ)
// izmantojot AddDate (y, m, d)
nextTomorrow := curTime. AddDate(0, 0, 2)
fmt. Println("Šoreiz Nākamais rīt ir: ", nākamaisRīt)
nākamais mēnesis:= Curtime. AddDate(0, 1, 0)
fmt. Println("Šis laiks nākammēnes ir: ", nākamais mēnesis)
FiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
fmt. Println ("Šoreiz piecus gadus un vienu mēnesi pēc tam ir: ", pieci gadiun viens mēnesis pēc)
}
Kas rada šādu produkciju:
Varat arī atņemt laiku ar Pievienot () un Pievienošanas datums() nododot negatīvos parametrus. Piemēram:
funcgalvenais() {
curTime := laiks. Tagad ()// atņemiet vienu dienu, izmantojot AddDate()
vakar := curTime. AddDate(0, 0, -1)
fmt. Println("Šoreiz vakar bija: ", vakar)
// atņemiet vienu mēnesi, izmantojot Add()
LastMonth := Curtime. Pievienot (laiks. Stunda * -24 * 30)
fmt. Println("Šis laiks pagājušajā mēnesī bija: ", pagājušajā mēnesī)
}
Ražo šādu produkciju:
Lai gan jūs varat izmantot Pievienot () un Pievienošanas datums() lai atrastu atšķirību starp datumiem, Go ir a Apakš() funkcija, kas darbojas nedaudz savādāk:
funcgalvenais() {
curTime = laiks. Tagad ()
pagātne := laiks. Datums(2022, laiks. decembris, 25, 12, 0, 0, 0, laiks. UTC)
atšķirība := pagātne. Apakšlaiks (curTime)
fmt. Println("Atšķirība starp tagadni un pagātni ir: ", atšķirība)
// iegūt atšķirību dažādās vienībās
gadi := starpt(atšķir. Stundas() / 24 / 365)
fmt. Println("Gadi: ", gadi)
mēneši := starpt(atšķir. Stundas() / 24 / 30)
fmt. Println("Mēneši: ", mēneši)
dienas := starpt(atšķir. Stundas() / 24)
fmt. Println("Dienas: ", dienas)
stundas := starpt(atšķir. Stundas())
fmt. Println("Stundas: ", stundas)
// atšķir. Minūtes(), atšķirība. Sekundes(), atšķirība. Milisekundes(), atšķirība. Nanosekundes () arī atgriež savas vienības
}
Šis kods rada šādu izvadi:
Kā uzzināt laiku un datumu dažādos formātos
Varat arī iegūt laika un datuma izvades vairākos formātos, izmantojot Formāts () funkciju. Šeit ir daži izplatīti formatēšanas stili:
funcgalvenais() {
curTime = laiks. Tagad ()
// iebūvētie standarta formatēšanas stili
fmt. Println("Pašreizējais laiks ir: ", curTime)
fmt. Println("Pašreizējais laiks RFC3339 formātā ir: ", curTime. Formāts (laiks. RFC3339))
fmt. Println("Pašreizējais laiks RFC3339Nano formātā ir: ", curTime. Formāts (laiks. RFC3339Nano))
fmt. Println("Pašreizējais laiks RFC1123 formātā ir: ", curTime. Formāts (laiks. RFC1123))
fmt. Println("Pašreizējais laiks RFC1123Z formātā ir: ", curTime. Formāts (laiks. RFC1123Z))
fmt. Println("Pašreizējais laiks RFC822 formātā ir: ", curTime. Formāts (laiks. RFC822))
fmt. Println("Pašreizējais laiks RFC822Z formātā ir: ", curTime. Formāts (laiks. RFC822Z))
fmt. Println("Pašreizējais laiks RFC850 formātā ir: ", curTime. Formāts (laiks. RFC850))
fmt. Println("Pašreizējais laiks ANSIC formātā ir: ", curTime. Formāts (laiks. ANSIC))
fmt. Println("Pašreizējais laiks Unix formātā ir: ", curTime. Formāts (laiks. UnixDate))
// pielāgoti formatēšanas stili
// DD-MM-GGGG HH: MM: SS
fmt. Println("Pašreizējais laiks pielāgotajā formātā ir: ", curTime. Formāts ("02-01-200615:04:05"))
// MM-DD-GGGG HH: MM: SS
fmt. Println("Pašreizējais laiks pielāgotajā formātā ir: ", curTime. Formāts ("01-02-200615:04:05"))
// GGGG-MM-DD HH: MM: SS
fmt. Println("Pašreizējais laiks pielāgotajā formātā ir: ", curTime. Formāts ("2006-01-0215:04:05"))
// DD.MM.GGGG
fmt. Println("Pašreizējais laiks pielāgotajā formātā ir: ", curTime. Formāts ("02.01.2006"))
// DD/MM/GGGG
fmt. Println("Pašreizējais laiks pielāgotajā formātā ir: ", curTime. Formāts ("02/01/2006"))
// 01.02.2006
fmt. Println("Pašreizējais laiks pielāgotajā formātā ir: ", curTime. Formāts ("02 janvāris 2006"))
// 01. februāris 2006 Pirmdiena
fmt. Println("Pašreizējais laiks pielāgotajā formātā ir: ", curTime. Formāts ("02 februāris 2006 pirmdiena"))
// 01. februāris 2006 P 15:04:05
fmt. Println("Pašreizējais laiks pielāgotajā formātā ir: ", curTime. Formāts ("02 februāris 2006 Pirmd 15:04:05"))
}
Šie dažādie formatēšanas veidi nodrošina šādu izvadi:
Manipulēšana ar laiku un datumu režīmā Go
To manipulāciju saraksts, kuras varat veikt noteiktos laikos un datumos, ir gandrīz bezgalīgs. Atkarībā no jūsu lietojumprogrammas jomas, iespējams, būs jāveic daudzas dažādas datuma/laika darbības.
Jebkurā lietošanas gadījumā, kas jums varētu būt, laiks pakotne ir ļoti funkcionāla, un tajā ir daudz iebūvētu metožu.
Varat izmantot datuma un laika manipulācijas, lai izveidotu vienkāršu ikdienas plānotāja vai uzdevumu plānotāja lietotni.
