Go Academy · Lekcja

Czas i czas trwania

Reprezentuj chwile i przedziały

Czas i czas trwania to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Pakiet time

Pakiet time w Go reprezentuje chwile oraz odstępy czasu między nimi.

time.Time oznacza konkretną chwilę.
time.Duration oznacza czas trwania.

package main

import (
    "fmt"
    "time"
)

func main() {
    var d time.Duration = 2 * time.Second
    fmt.Println(d)
}

Pobieranie bieżącego czasu

time.Now() zwraca bieżącą chwilę jako wartość typu time.Time. (Jej dokładna wartość zależy od momentu uruchomienia programu).

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now.Year())
}

Tworzenie określonego czasu

time.Date tworzy dokładną chwilę na podstawie jej elementów: roku, miesiąca, dnia, godziny, minuty, sekundy, nanosekundy i lokalizacji.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    fmt.Println(t)
}

Odczytywanie składników czasu

Wartość typu time.Time udostępnia metody takie jak Year, Month, Day, Hour i Weekday.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 0, 0, 0, 0, time.UTC)
    fmt.Println(t.Month(), t.Day(), t.Weekday())
}

Stałe jednostek czasu trwania

Czas trwania można tworzyć przez mnożenie stałych jednostek: time.Hour, time.Minute, time.Second, time.Millisecond.

package main

import (
    "fmt"
    "time"
)

func main() {
    d := 1*time.Hour + 30*time.Minute
    fmt.Println(d)
}

Konwertowanie czasu trwania

Metody takie jak Seconds(), Minutes() i Hours() zwracają czas trwania jako wartość float64 wyrażoną w danej jednostce.

package main

import (
    "fmt"
    "time"
)

func main() {
    d := 90 * time.Minute
    fmt.Println(d.Hours())
    fmt.Println(d.Seconds())
}

Dodawanie czasu

t.Add(d) zwraca nowy czas przesunięty o podany czas trwania. Oryginalna wartość pozostaje niezmieniona, ponieważ time.Time jest typem wartościowym.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    later := t.Add(2 * time.Hour)
    fmt.Println(later.Hour())
}

Dodawanie jednostek kalendarzowych

t.AddDate(years, months, days) przesuwa czas o podaną liczbę lat, miesięcy i dni, poprawnie uwzględniając długość miesięcy oraz lata przestępne.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, time.January, 31, 0, 0, 0, 0, time.UTC)
    next := t.AddDate(0, 1, 0)
    fmt.Println(next.Month(), next.Day())
}

Różnica między czasami

t2.Sub(t1) zwraca wartość typu Duration określającą czas między dwoma momentami. Ujemny wynik oznacza, że t2 jest wcześniejszy.

package main

import (
    "fmt"
    "time"
)

func main() {
    a := time.Date(2026, time.May, 30, 9, 0, 0, 0, time.UTC)
    b := time.Date(2026, time.May, 30, 12, 0, 0, 0, time.UTC)
    fmt.Println(b.Sub(a))
}

Porównywanie czasów

Do porównywania punktów w czasie należy używać funkcji Before, After i Equal. Należy unikać operatora ==, ponieważ porównuje on również wewnętrzną lokalizację.

package main

import (
    "fmt"
    "time"
)

func main() {
    a := time.Date(2026, 5, 30, 9, 0, 0, 0, time.UTC)
    b := time.Date(2026, 5, 30, 10, 0, 0, 0, time.UTC)
    fmt.Println(a.Before(b))
}

Znaczniki czasu Unix

t.Unix() zwraca liczbę sekund od 1 stycznia 1970 roku. time.Unix(sec, 0) konwertuje ją z powrotem na wartość typu time.Time.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, 5, 30, 0, 0, 0, 0, time.UTC)
    secs := t.Unix()
    fmt.Println(time.Unix(secs, 0).UTC().Year())
}

Szybkie sprawdzenie

Co zwraca t2.Sub(t1)?

Podsumowanie: czas i czas trwania

Poznano podstawowy model czasu:

time.Time oznacza punkt w czasie, a time.Duration — czas trwania.
Wartości tworzy się za pomocą Now i Date, a przesuwa za pomocą Add i AddDate.
Czas mierzy się za pomocą Sub, a wartości porównuje za pomocą Before/After.

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Date(2026, 5, 30, 8, 0, 0, 0, time.UTC)
    end := start.Add(45 * time.Minute)
    fmt.Println(end.Sub(start).Minutes(), "minutes")
}

Często zadawane pytania

Czy lekcja „Czas i czas trwania” jest bezpłatna?

Tak — pełny tekst „Czas i czas trwania” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Czas i czas trwania”?

Reprezentuj chwile i przedziały Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Czas i czas trwania”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy