Skip to content

Sana va vaqt bilan ishlash

Go da sana va vaqt bilan ishlash uchun time paketi mavjud, quyida bu paket bilan ishlashni ko'rib chiqamiz.

Ayni vaqtni aniqlash.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Ayni vaqt:", time.Now())
}

Natija:

Ayni vaqt: 2025-08-02 15:50:06.3940473 +0500 +05 m=+0.001661801

Natijani qismlarga ajratib tushuntiramiz:

Qism Ma'nosi
2025-08-02 yil-oy-kun
15:50:06.3940473 Soat:daqiqasi:soniya.nanosekunda (15:50:06 va 3940473 nanosekunda)
+0500 UTC offset: bu vaqt UTC'dan +5 soat oldin (ya'ni, Asia/Tashkent vaqti)
+05 Bu ham zona offset, ammo bu qisqa variant (ba'zida vaqt zonasi kodini bildiradi)
m=+0.001661801 Bu monotonic clock qiymati: dastur boshlanganidan buyon qancha vaqt o'tgani (sekundlarda)

Info

Monotonic Time - operatsion tizim tomonidan taqdim etiladigan timer bo'lib, kompyuter yoqilganidan keyin yoki dasturning ishga tushganidan buyon o'tgan vaqtni aniq o'lchash uchun ishlatiladi. Goda Monotonic Time Go dastur boshlangandan beri o'tgan vaqt.

Yuqoridagi misolda chiqgan natijada bizga keraksiz bo'lgan qismlar ham bor, sanani va vaqtni alohida ajratib olishimiz kerak. Buning uchun bizga sana va vaqtni formatlab olish funksiyasi kerak bo'ladi.

Sana va vaqtni formatlash

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
package main

import (
    "fmt"
    "time"
)

func main() {
    hozir := time.Now()
    sana := hozir.Format("02-01-2006")
    soat := hozir.Format("15:04:05")

    fmt.Println("sana: ", sana)
    fmt.Println("soat: ", soat)
}

Natija:

sana:  02-08-2025
soat:  16:09:15

Yuqoridagi misol uchun sizda 02-01-2006, 15:04:05 va Format nima degan savollar tug'ilgan bo'lishi mumkin quyida tushuntirib o'tamiz.

  • time.Format() — Go'da sana/vaqtni qanday ko'rinishda chiqishini belgilab beradi.
  • 02-01-2006 bu Go tilida sananing maxsus namunasi. Go da sana uchun namuna shunday qabul qilingan agar bu namuna o'zgarsa kutilgan natija olinmaydi, oddiy matn deb qabul qiladi. Quyida namunalar uchun foydalanishga mo'ljallangan maxsus so'zlar jadval ko'rinishida keltrilgan.

time.Format uchun maxsus so'zlar

Format Tushuntirish
2006 Yil (to'liq)
06 Yil (so'nggi 2 raqam)
01 Oy (raqam, 2 xonali)
Jan Oy nomi (3 harf)
January Oy nomi (to'liq)
02 Kun (oy kuni, 2 xonali)
Monday Haftaning to'liq nomi
Mon Haftaning qisqa nomi
15 Soat (24-soat formatda)
03 Soat (12-soat formatda)
PM AM/PM (katta harf)
pm am/pm (kichik harf)
04 Daqiqa (2 xonali)
05 Soniya (2 xonali)
.000 Millisekund (3 xonali)
.000000 Mikrosekund (6 xonali)
.000000000 Nanosekund (9 xonali)
MST Vaqt zonasi qisqa nomi
-0700 Vaqt zonasi offset (soat/dakika)
-07:00 Vaqt zonasi offset (: bilan)
Z07:00:00 To'liq offset (soat:min:sek)

Misol:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main

import (
    "fmt"
    "time"
)

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

    fmt.Println("2006       (Yil to'liq oy nomi bilan) ->", now.Format("January 2, 2006 15:04:05"))
    fmt.Println("2006       (Yil to'liq)             ->", now.Format("2006"))
    fmt.Println("06         (Yil oxirgi 2 raqam)     ->", now.Format("06"))
    fmt.Println("01         (Oy raqam, 2 xonali)     ->", now.Format("01"))
    fmt.Println("Jan        (Oy qisqa nomi)          ->", now.Format("Jan"))
    fmt.Println("January    (Oy to'liq nomi)         ->", now.Format("January"))
    fmt.Println("02         (Kun, 2 xonali)          ->", now.Format("02"))
    fmt.Println("Monday     (Hafta kuni, to'liq)     ->", now.Format("Monday"))
    fmt.Println("Mon        (Hafta kuni, qisqa)      ->", now.Format("Mon"))
    fmt.Println("15         (Soat 24h formatda)      ->", now.Format("15"))
    fmt.Println("03         (Soat 12h formatda)      ->", now.Format("03"))
    fmt.Println("PM         (AM/PM katta harf)       ->", now.Format("PM"))
    fmt.Println("pm         (am/pm kichik harf)      ->", now.Format("pm"))
    fmt.Println("04         (Daqiqa)                 ->", now.Format("04"))
    fmt.Println("05         (Soniya)                 ->", now.Format("05"))
    fmt.Println(".000       (Millisekund)            ->", now.Format(".000"))
    fmt.Println(".000000    (Mikrosekund)            ->", now.Format(".000000"))
    fmt.Println(".000000000 (Nanosekund)             ->", now.Format(".000000000"))
    fmt.Println("MST        (Vaqt zonasi nomi)       ->", now.Format("MST"))
    fmt.Println("-0700      (UTC offset)             ->", now.Format("-0700"))
    fmt.Println("-07:00     (UTC offset, `:` bilan) ->", now.Format("-07:00"))
    fmt.Println("Z07:00:00  (To'liq offset)           ->", now.Format("Z07:00:00"))
}

Natija:

2006       (Yil to'liq)             -> August 2, 2025 16:25:38
2006       (Yil to'liq)             -> 2025
06         (Yil oxirgi 2 raqam)     -> 25
01         (Oy raqam, 2 xonali)     -> 08
Jan        (Oy qisqa nomi)          -> Aug
January    (Oy to'liq nomi)         -> August
02         (Kun, 2 xonali)          -> 02
Monday     (Hafta kuni, to'liq)     -> Saturday
Mon        (Hafta kuni, qisqa)      -> Sat
15         (Soat 24h formatda)      -> 16
03         (Soat 12h formatda)      -> 04
PM         (AM/PM katta harf)       -> PM
pm         (am/pm kichik harf)      -> pm
04         (Daqiqa)                 -> 25
05         (Soniya)                 -> 38
.000       (Millisekund)            -> .214
.000000    (Mikrosekund)            -> .214416
.000000000 (Nanosekund)             -> .214416400
MST        (Vaqt zonasi nomi)       -> +05
-0700      (UTC offset)             -> +0500
-07:00     (UTC offset, `:` bilan) -> +05:00
Z07:00:00  (To'liq offset)           -> +05:00:00

Satrni vaqtga o'girish

Go tilida satr -> time.Time konvertatsiyasi uchun time.Parse() funksiyasidan foydalaniladi.

Bu funksiya quyidagicha ishlaydi:

t, err := time.Parse(format, string)

format bu yerda time.Format() dagi kabi 2006-01-02 15:04:05 namunasi bo'yicha yoziladi.

Misol:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
package main

import (
    "fmt"
    "time"
)

func main() {
    sanaStr := "2025-08-02"
    format := "2006-01-02"

    sana, err := time.Parse(format, sanaStr)
    if err != nil {
        fmt.Println("Xatolik:", err)
        return
    }

    fmt.Println("Sana:", sana)
}

Natija:

Sana: 2025-08-02 00:00:00 +0000 UTC

Vaqt bo'yicha ham yuqoridagi kabi o'giriladi, quyida vaqt va vaqt zonasi bo'yicha misol ko'ramiz:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
    "fmt"
    "time"
)

func main() {
    loc, err := time.LoadLocation("Asia/Tashkent")
    if err != nil {
        panic(err)
    }

    dtStr := "2025-08-02 14:30"
    layout := "2006-01-02 15:04"

    t, err := time.ParseInLocation(layout, dtStr, loc)
    if err != nil {
        fmt.Println("Xatolik:", err)
        return
    }

    fmt.Println("Asia/Tashkent zonasi:", t)
}

Natija:

Asia/Tashkent zonasi: 2025-08-02 14:30:00 +0500 +05

Goda vaqt va sana bo'yicha ishlashni boshqa imkoniyatlari

Vaqtni qo'lda hosil qilishni yana bir usuli:

t := time.Date(2025, 8, 2, 14, 30, 0, 0, time.UTC)

Vaqtga qo'shish:

t := time.Now().Add(2 * time.Hour) // 2 soat qo'shiladi

Vaqt ayirish:

t := time.Now().Add(-2 * time.Hour) // 2 soat ayiriladi

Sanaga qo'shish:

t := time.Now().AddDate(0, 1, 7) // 1 oy va 7 kun qo'shish

Sana ayirish:

t := time.Now().today.AddDate(0, -2, 0) // 2 oy ayirish

Vaqt kutish:

time.Sleep(1 * time.Second)
time.Sleep(1 * time.Millisecond)
time.Sleep(1 * time.Nanosecond)
time.Sleep(1 * time.Microsecond)
time.Sleep(1 * time.Minute)
time.Sleep(1 * time.Hour)
📍 Toshkent, O‘zbekiston
🗓️
👤