Apps Artificial Intelligence CSS DevOps Go JavaScript Laravel Linux MongoDB MySQL PHP Python Rust Svelte Vue

Working with Time in Go Without the Headaches

1 min read .
Updated on
Working with Time in Go Without the Headaches

Time handling looks simple until time zones, parsing, durations, and scheduling enter the picture. Go’s standard time package covers the common cases without requiring third-party libraries.

Current Time

currentTime := time.Now()
fmt.Println("Now:", currentTime)

time.Now() returns the current local time according to the process environment.

Format and Parse

Go uses a reference-time layout instead of symbols such as YYYY or MM. The reference is:

Mon Jan 2 15:04:05 MST 2006

For example:

formatted := currentTime.Format("2006-01-02 15:04:05")
fmt.Println("Formatted:", formatted)

parsed, err := time.Parse("2006-01-02 15:04:05", "2024-08-24 13:45:00")
if err != nil {
    log.Fatal(err)
}
fmt.Println("Parsed:", parsed)

time.Parse interprets a layout without a zone as UTC. If the input represents time in a specific location, use time.ParseInLocation.

Add Durations and Calculate Differences

future := currentTime.Add(2 * time.Hour)
past := currentTime.Add(-30 * time.Minute)

fmt.Println("Two hours from now:", future)
fmt.Println("Thirty minutes ago:", past)
fmt.Println("Difference:", future.Sub(currentTime))

time.Duration is useful for elapsed time such as seconds, minutes, and hours. Calendar operations involving months or years should normally use AddDate instead because calendar units do not have fixed durations.

nextMonth := currentTime.AddDate(0, 1, 0)

Work with Time Zones

loc, err := time.LoadLocation("Asia/Jakarta")
if err != nil {
    log.Fatal(err)
}

fmt.Println("Jakarta time:", currentTime.In(loc))

On systems without time-zone data, LoadLocation can fail. Go applications running in minimal containers may need the time/tzdata package embedded in the binary.

Periodic Work with a Ticker

ticker := time.NewTicker(2 * time.Second)
defer ticker.Stop()

for i := 0; i < 5; i++ {
    t := <-ticker.C
    fmt.Println("Tick:", t)
}

For server applications, combine tickers with a context.Context so background work can stop during shutdown.

Conclusion

The time package covers current timestamps, formatting, parsing, durations, time zones, and simple periodic scheduling. The main pitfalls are usually semantic rather than syntactic: know which time zone an input belongs to, distinguish elapsed durations from calendar arithmetic, and always handle parsing or location-loading errors.

Golang

Related Posts

Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter
Updated on
Arrays and Slices in Go: Add, Delete, Search, Update, Sort, and Filter
Go arrays and slices are straightforward once you understand their different roles. Arrays have a fixed length that is part of their type, while slices are flexible views over an underlying array and are the collection type used most often in application code. The following examples use a slice of structs: Copy type Person struct { Name string Age int } people := []Person{ {Name: "Alice", Age: 30}, {Name: "Bob", Age: 25}, {Name: "John", Age: 20}, {Name: "Zara", Age: 35}, } 1. Add an Element Use append:
Golang Array Slice
Build a CRUD API with Go, Gin, MySQL, and GORM
Updated on
Build a CRUD API with Go, Gin, MySQL, and GORM
This tutorial builds a small CRUD API with Go, the Gin web framework, MySQL, and GORM. It also uses godotenv for local development configuration. 1. Create the Project Copy mkdir myapp cd myapp go mod init myapp 2. Install Dependencies Copy go get github.com/gin-gonic/gin go get gorm.io/gorm go get gorm.io/driver/mysql go get github.com/joho/godotenv Run go mod tidy after adding your imports so the module file reflects the dependencies actually used by the application.
Golang Gin MySQL GORM
Deploy a Go Web Server with systemd on Linux
Updated on
Deploy a Go Web Server with systemd on Linux
When developing a small Go web server, it is common to run it manually with go run main.go. The problem is that the process stops when the terminal closes, and it will not automatically return after a server reboot. A better production setup is to run the application as a systemd service. That gives you automatic startup, monitoring, service management, and optional restart behavior after failures. 1. Create a Simple Go Web Server Start with a minimal HTTP server:
Golang systemd
Easy Ways to Convert an Integer to a String in Go
Updated on
Easy Ways to Convert an Integer to a String in Go
Converting an integer to a string is common when building output, logs, identifiers, URLs, or serialized data. Go provides several standard-library options depending on whether you need a simple decimal conversion or more control over formatting. 1. strconv.Itoa() For an int in base 10, strconv.Itoa is usually the clearest choice: Copy package main import ( "fmt" "strconv" ) func main() { num := 42 str := strconv.Itoa(num) fmt.Println("String value:", str) } Itoa is equivalent to formatting the int as a base-10 integer.
Golang
Efficient String Concatenation in Go
Updated on
Efficient String Concatenation in Go
String concatenation appears everywhere in Go programs: generating text, building paths, formatting reports, or assembling protocol messages. The best technique depends on how many pieces you are joining and how the data is already structured. 1. The + Operator For a small, fixed number of strings, + is clear and perfectly reasonable: Copy str1 := "Hello, " str2 := "world!" result := str1 + str2 Avoid repeatedly growing a string with + inside a large loop, because each result is a new immutable string and repeated copying can become expensive.
Golang
Generate Random Strings in Go
Updated on
Generate Random Strings in Go
Random strings are useful for temporary identifiers, test data, filenames, invitation codes, and security-sensitive tokens. Go offers different random-number sources, and choosing the correct one matters. 1. math/rand for Non-Security Uses For simulations, test fixtures, randomized UI behavior, or other cases where predictability is not a security problem, math/rand is appropriate. With modern Go, create an explicit generator when you need independent pseudo-random state: Copy package main import ( "fmt" "math/rand" ) const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" func GenerateRandomString(r *rand.Rand, length int) string { result := make([]byte, length) for i := range result { result[i] = alphabet[r.Intn(len(alphabet))] } return string(result) } func main() { r := rand.New(rand.NewSource(42)) fmt.Println(GenerateRandomString(r, 10)) } A fixed seed is useful for reproducible tests. Do not use math/rand for secrets, session tokens, password-reset tokens, or other authentication material.
Golang
chevron-up