20. Working with Time

⏰ Unlock the complexities of time in programming! This guide comprehensively covers time package basics, formatting, arithmetic, timers, and time zones, empowering you to handle any date and time challenge with precision. 🚀

Posted Dec 4, 2025

By Youth Innovations

14 min read

What we will learn in this post?

👉 Time Package Basics
👉 Formatting and Parsing Time
👉 Time Arithmetic
👉 Timers and Tickers
👉 Time Zones
👉 Conclusion!

⏰ Understanding Go’s `time` Package

Go’s built-in time package is your friendly helper for all things related to dates and times! It’s super handy for tasks like logging events, scheduling, or simply showing when something happened.

🗓️ The `time.Time` Type

At the heart of this package is the time.Time type. This type represents a precise instant in time – a specific point on the global timeline, down to the nanosecond. Imagine it as a digital timestamp.

🚀 Current Time with `time.Now()`

Want to know the current moment? Just use time.Now(). This function gives you a time.Time object reflecting the exact time your code runs.

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

🛠️ Making Specific Times with `time.Date()`

To create a time.Time object for a particular date and time you have in mind, time.Date() is your go-to. You specify the year, month, day, hour, minute, second, nanosecond, and timezone.

  
specificTime := time.Date(2024, time.January, 1, 9, 0, 0, 0, time.UTC)
// fmt.Println("New Year 2024:", specificTime)

✨ Common Time Operations

Once you have a time.Time object, you can easily perform many operations:

Format: Display time beautifully, e.g., t.Format("2006-01-02").
Add/Subtract: Shift time by a duration, e.g., t.Add(time.Hour * 2).
Compare: Check if one time is t1.Before(t2) or t1.After(t2) another.

🌊 Time Creation Flow

graph TD
    A["🎬 Start"]:::pink --> B{"⏰ Need a time?"}:::gold
    B -- "📍 Current moment?" --> C["📞 Call time.Now()"]:::purple
    B -- "📅 Specific date/time?" --> D["🛠️ Call time.Date(year, month, ...)"]:::teal
    C --> E["📦 Get time.Time Object"]:::green
    D --> E
    E --> F["⚙️ Perform operations<br/>(format, add, compare)"]:::orange

    classDef pink fill:#ff4f81,stroke:#c43e3e,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef gold fill:#ffd700,stroke:#d99120,color:#222,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef purple fill:#6b5bff,stroke:#4a3f6b,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef teal fill:#00bfae,stroke:#005f99,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef green fill:#43e97b,stroke:#38f9d7,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef orange fill:#ff9800,stroke:#f57c00,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;

    linkStyle default stroke:#e67e22,stroke-width:3px;

Go’s Time Magic: Formatting & Parsing! ⏰

Go’s built-in time package makes handling dates and times super easy! It uses a unique approach with a reference time for both formatting and parsing.

🎨 Formatting Time with `Format()`

The time.Format() method is your go-to for turning a time.Time object into a beautiful, custom string. You provide a layout string where each part directly corresponds to an element in Go’s fixed reference time: Mon Jan 2 15:04:05 MST 2006. Whatever component of the reference time you include in your layout, Go uses that specific element’s value to represent the actual time’s component.

Example: To get MM/DD/YYYY HH:MM PM, you’d use "01/02/2006 03:04 PM".

  
package main
import ( "fmt"; "time" )
func main() {
	t := time.Date(2023, time.December, 25, 15, 4, 5, 0, time.UTC)
	fmt.Println("Formatted Time:", t.Format("01/02/2006 03:04 PM"))
	// Output: Formatted Time: 12/25/2023 03:04 PM
}

📜 Parsing Time with `Parse()`

Need to convert a date/time string back into a time.Time object? That’s what time.Parse() is for! The trick is that the layout string you provide must exactly match the format of your input time string.

Example: To parse "12/25/2023", the layout is "01/02/2006".

  
package main
import ( "fmt"; "time" )
func main() {
	dateString := "12/25/2023"
	parsedTime, _ := time.Parse("01/02/2006", dateString)
	fmt.Println("Parsed Time:", parsedTime.Format("January 2, 2006"))
	// Output: Parsed Time: December 25, 2023
}

🤔 Why the “Reference Time”?

Go uses Mon Jan 2 15:04:05 MST 2006 because it’s a memorable and intuitive date/time with unique values for each component. Instead of obscure symbols (%Y, DD), you just use the actual numbers/names from the reference time. Want the year? Use 2006. Want the month number? Use 01. This approach is language-agnostic and very clear!

A Quick Flow for Formatting 🌊

graph TD
    A["⏰ time.Time Object"]:::pink --> B{"🎨 Call .Format layout"}:::gold
    B -- "📋 Layout String uses" --> C["📅 Reference Time<br/>Mon Jan 2 15:04:05 2006"]:::purple
    C --> D["🔄 Go maps layout<br/>components"]:::teal
    D --> E["✨ Output Custom<br/>Formatted String"]:::green

    classDef pink fill:#ff4f81,stroke:#c43e3e,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef gold fill:#ffd700,stroke:#d99120,color:#222,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef purple fill:#6b5bff,stroke:#4a3f6b,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef teal fill:#00bfae,stroke:#005f99,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef green fill:#43e97b,stroke:#38f9d7,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;

    linkStyle default stroke:#e67e22,stroke-width:3px;

For a deeper dive, explore the official Go time package documentation.

⏰ Understanding Go’s time.Duration

Go’s time.Duration is a fundamental type representing a length of time or an interval, like “5 minutes” or “3 hours.” Internally, it’s stored as an int64 count of nanoseconds. This makes working with time differences and intervals incredibly precise and straightforward!

➕➖ Adding & Subtracting Durations

You can easily manipulate time.Time and time.Duration values:

The Add() method allows you to add a time.Duration to a time.Time to get a new, future time.Time. It can also add two time.Duration values.
The Sub() method subtracts a time.Duration from another time.Duration, or a time.Time from another time.Time (returning a time.Duration).

  
import "time"

func main() {
    now := time.Now()
    future := now.Add(10 * time.Minute) // Add 10 minutes
    
    duration1 := 30 * time.Second
    duration2 := 5 * time.Second
    sumDuration := duration1.Add(duration2) // sumDuration is 35s
    remaining := duration1.Sub(duration2)   // remaining is 25s
}

🕰️ Calculating Time Differences

To find the difference between two time.Time objects, use the Sub() method on the earlier time, passing the later time. The result is a time.Duration.

  
import "time"

func main() {
    start := time.Now()
    time.Sleep(2 * time.Second) // Simulate some work
    end := time.Now()

    elapsed := end.Sub(start) // elapsed will be approximately 2 seconds
    // fmt.Println(elapsed) // Prints something like "2.0000002s"
}

🌟 Common Duration Constants

Go provides helpful constants for common durations, improving code readability:

time.Second
time.Minute
time.Hour
time.Millisecond, time.Microsecond, time.Nanosecond

graph TD
    A["⏰ time.Time"]:::pink -- "➕ Add(Duration)" --> B["🆕 New time.Time"]:::green
    C["⏰ time.Time"]:::pink -- "➖ Sub(time.Time)" --> D["⏱️ time.Duration"]:::teal
    E["⏱️ time.Duration"]:::teal -- "➕ Add(Duration)" --> F["🔗 Combined Duration"]:::purple
    G["⏱️ time.Duration"]:::teal -- "➖ Sub(Duration)" --> H["📉 Remaining Duration"]:::orange

    classDef pink fill:#ff4f81,stroke:#c43e3e,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef green fill:#43e97b,stroke:#38f9d7,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef teal fill:#00bfae,stroke:#005f99,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef purple fill:#6b5bff,stroke:#4a3f6b,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef orange fill:#ff9800,stroke:#f57c00,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;

    linkStyle default stroke:#e67e22,stroke-width:3px;

Mastering Go’s Time Utilities: Timers & Tickers ⏰

Go’s time package offers powerful tools for scheduling code execution: Timer for one-time delays, After() for quick convenience, and Ticker for repeated actions. Understanding how to use and properly stop them is key to preventing resource leaks.

`time.Timer` for One-Time Delays ⏱️

A time.Timer allows you to execute code exactly once after a specified duration.

Usage: Create with time.NewTimer(duration). It returns a channel C that sends a value when the timer expires.

  
timer := time.NewTimer(2 * time.Second)
<-timer.C // Waits for 2 seconds
fmt.Println("Timer fired!")

Stopping: If you no longer need the timer before it fires, call timer.Stop(). This is crucial to release its resources and prevent leaks.

`time.After()` for Quick Delays 🚀

time.After() is a handy shortcut for a simple, one-off delay. It returns a <-chan Time that receives the current time after the given duration.

Usage:

  
<-time.After(1 * time.Second) // Waits 1 second
fmt.Println("After channel received!")

Stopping: No explicit stopping is needed; once the value is sent, its internal goroutine is usually garbage collected. It’s great for timeouts!

`time.Ticker` for Repeated Actions 🔄

For actions that need to happen repeatedly at regular intervals, time.Ticker is your go-to.

Usage: Initialize with time.NewTicker(interval). Its C channel sends a value at each interval.

  
ticker := time.NewTicker(500 * time.Millisecond)
defer ticker.Stop() // ESSENTIAL for cleanup!

for range ticker.C {
    fmt.Println("Tick! Doing something every 500ms.")
    // Perform your periodic task here
}

Stopping: Always call ticker.Stop() when you’re done. Failing to do so will lead to goroutine and memory leaks!

Preventing Leaks: The `Stop()` Method 🛑

Both time.Timer and time.Ticker involve internal goroutines. Calling their Stop() method ensures these goroutines are cleaned up, releasing associated memory and preventing resource leaks. For time.Timer, Stop() also prevents a value from being sent on the channel if it hasn’t fired yet.

%%{init: {'theme':'base', 'themeVariables': { 
  'primaryColor':'#ff4f81',
  'primaryTextColor':'#fff',
  'primaryBorderColor':'#c43e3e',
  'lineColor':'#e67e22',
  'secondaryColor':'#6b5bff',
  'tertiaryColor':'#ffd700',
  'noteBkgColor':'#ff4f81',
  'noteTextColor':'#fff',
  'noteBorderColor':'#c43e3e',
  'actorBkg':'#00bfae',
  'actorBorder':'#005f99',
  'actorTextColor':'#fff',
  'actorLineColor':'#e67e22',
  'signalColor':'#fff',
  'signalTextColor':'#c3a7c7ff',
  'labelBoxBkgColor':'#43e97b',
  'labelBoxBorderColor':'#38f9d7',
  'labelTextColor':'#fff',
  'loopTextColor':'#fff',
  'activationBorderColor':'#ff9800',
  'activationBkgColor':'#ffd700',
  'sequenceNumberColor':'#fff',
  'fontSize':'18px',
  'fontFamily':'Trebuchet MS, Verdana, Arial, sans-serif'
}}}%%
sequenceDiagram
    autonumber
    participant YourCode as 💻 Your Go Code
    participant GoRuntime as ⚙️ Go Runtime (Time Pkg)
    
    Note over YourCode,GoRuntime: 🎯 Timer/Ticker Lifecycle
    
    rect rgb(107, 91, 255, .1)
    Note right of YourCode: Initialization Phase
    YourCode->>+GoRuntime: 🚀 NewTicker(interval)
    GoRuntime-->>-YourCode: 📡 ticker.C channel
    end
    
    rect rgb(0, 191, 174, .1)
    Note right of GoRuntime: Execution Phase
    loop ♻️ Routine Operations
        GoRuntime->>YourCode: ⏰ Send event on ticker.C
        YourCode->>YourCode: 🔧 Process periodic task
    end
    end
    
    rect rgb(255, 79, 129, .1)
    Note right of YourCode: Cleanup Phase
    YourCode->>+GoRuntime: 🛑 ticker.Stop()
    GoRuntime-->>GoRuntime: 🧹 Cleanup goroutine & resources
    GoRuntime-->>-YourCode: ✅ Confirmation (implicit)
    end

📍 What is `time.Location`?

A time.Location represents a specific time zone, like New York or Tokyo. It’s key to correctly interpreting and displaying time.Time values.

🌐 Getting Your Time Zone Locations

Go offers several ways to obtain a time.Location object:

🌍 Universal Time: time.UTC
- Represents Coordinated Universal Time, the global standard, free from daylight saving changes.
🏡 Local System Time: time.Local
- Corresponds to the time zone set on your computer or server.
🗺️ Named Zones: time.LoadLocation()
- Loads a time.Location by its IANA Time Zone name (e.g., "America/New_York", "Asia/Tokyo").
- Returns an error if the name is invalid or the zone data isn’t found.

🔄 Converting Times with `.In()`

The t.In(location) method allows you to re-interpret an existing time.Time value in a new time.Location. Important: it doesn’t change the moment in time, only how that moment is expressed (e.g., 10 AM UTC is 6 AM in New York).

💡 Practical Example

Let’s see it in action:

  
package main

import (
	"fmt"
	"time"
)

func main() {
	// A specific moment in UTC
	utcTime := time.Date(2023, time.October, 27, 10, 0, 0, 0, time.UTC)
	fmt.Println("UTC time:", utcTime) 
	// Output: UTC time: 2023-10-27 10:00:00 +0000 UTC

	// Load New York's time zone
	nyLoc, _ := time.LoadLocation("America/New_York") // Error handling omitted for brevity
	
	// Convert UTC time to New York time
	nyTime := utcTime.In(nyLoc)
	fmt.Println("New York time:", nyTime) 
	// Output: New York time: 2023-10-27 06:00:00 -0400 EDT

	// Load Tokyo's time zone
	tokyoLoc, _ := time.LoadLocation("Asia/Tokyo") // Error handling omitted for brevity

	// Convert UTC time to Tokyo time
	tokyoTime := utcTime.In(tokyoLoc)
	fmt.Println("Tokyo time:", tokyoTime) 
	// Output: Tokyo time: 2023-10-27 19:00:00 +0900 JST
}

✨ How Time Zone Conversion Works

graph TD
    A["⏰ Initial time.Time Object"]:::pink
    B["📍 Target time.Location Object"]:::gold
    A -- "🔄 Call .In B" --> C["✨ New time.Time Object<br/>in Target Location"]:::green
    subgraph ObtainLocation ["🌍 Obtaining Target Location"]
        D["🌐 time.UTC"]:::teal
        E["🏡 time.Local"]:::purple
        F["🗺️ time.LoadLocation<br/>Zone/Name"]:::orange
    end
    D --> B
    E --> B
    F --> B

    classDef pink fill:#ff4f81,stroke:#c43e3e,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef gold fill:#ffd700,stroke:#d99120,color:#222,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef green fill:#43e97b,stroke:#38f9d7,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef teal fill:#00bfae,stroke:#005f99,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef purple fill:#6b5bff,stroke:#4a3f6b,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;
    classDef orange fill:#ff9800,stroke:#f57c00,color:#fff,font-size:14px,stroke-width:3px,rx:12,shadow:4px;

    linkStyle default stroke:#e67e22,stroke-width:3px;

📚 Resources

🎮 Try It Live: Time Package Playground

🚀 Try this Live → Click to open interactive GO playground

🎯 Hands-On Assignment

💡 Project: Event Scheduler & Countdown System (Click to expand)

🚀 Your Challenge:

Build a comprehensive Event Scheduler and Countdown System in Go that manages multiple events, displays countdowns, handles time zones, and sends reminders. Your system should demonstrate mastery of Go's time package capabilities. ⏰✨

📋 Requirements:

Part 1: Event Management System

Create an Event struct with fields:
- Name (string)
- Description (string)
- StartTime (time.Time)
- EndTime (time.Time)
- Location (time zone name)
- ReminderMinutes (int) - minutes before event to send reminder
Implement AddEvent() function to create and store events
Format event details with proper timezone display
Calculate event duration using time.Duration

Part 2: Countdown Timer

Implement TimeUntilEvent() that calculates time remaining until event starts
Display countdown in days, hours, minutes, and seconds
Handle past events (show "Event has passed")
Create LiveCountdown() using time.Ticker that updates every second
Format countdown display: "2 days, 5 hours, 30 minutes, 15 seconds"

Part 3: Multi-Timezone Support

Convert event times between different time zones
Implement ShowEventInTimezone(event Event, targetZone string)
Display events in: UTC, America/New_York, Europe/London, Asia/Tokyo
Handle daylight saving time automatically
Show offset from UTC for each timezone

Part 4: Event Reminders

Use time.Timer to schedule reminders
Create SetReminder() function that triggers at specified time before event
Handle multiple reminders (e.g., 24 hours, 1 hour, 15 minutes before)
Print reminder messages with event details
Allow reminder cancellation using timer.Stop()

Part 5: Event Parsing & Formatting

Parse event times from various string formats:
- "2024-12-25 10:00:00"
- "12/25/2024 10:00 AM"
- "December 25, 2024 at 10:00 AM"
Implement robust error handling for invalid dates
Format events for display in multiple styles
Export events to ISO 8601 format

Part 6: Schedule Analysis

Find overlapping events (events happening at same time)
Calculate total event time for a given day/week/month
Sort events chronologically
Find next upcoming event
Generate weekly schedule report

💡 Implementation Hints:

Step 1: Start with Event struct and basic Add/Display functions
Step 2: Use time.Until(eventTime) for countdown calculations
Step 3: Use time.LoadLocation() for timezone handling with proper error checking
Step 4: Create goroutines for each reminder timer to run concurrently
Step 5: Use time.Parse() with multiple layout formats in a loop
Step 6: Sort events using sort.Slice() with Before() comparison
Bonus: Add recurring events (daily, weekly, monthly)
Advanced: Implement iCalendar (.ics) file import/export

🎨 Example Usage:

// Create events
event1 := Event{
    Name: "Team Meeting",
    Description: "Q4 Planning Discussion",
    StartTime: time.Date(2024, time.December, 25, 10, 0, 0, 0, time.UTC),
    EndTime: time.Date(2024, time.December, 25, 11, 30, 0, 0, time.UTC),
    Location: "America/New_York",
    ReminderMinutes: 30,
}

// Display countdown
countdown := TimeUntilEvent(event1)
fmt.Printf("Time until %s: %s\n", event1.Name, FormatDuration(countdown))

// Convert to different timezone
ShowEventInTimezone(event1, "Asia/Tokyo")

// Set reminder
SetReminder(event1, func() {
    fmt.Printf("⏰ Reminder: %s starts in 30 minutes!\n", event1.Name)
})

Expected Output Example:

EVENT SCHEDULER SYSTEM
======================

📅 Event: Team Meeting
📝 Description: Q4 Planning Discussion
🕒 Start: 2024-12-25 10:00:00 EST
🕕 End: 2024-12-25 11:30:00 EST
⏱️ Duration: 1 hour 30 minutes
⏳ Countdown: 5 days, 12 hours, 45 minutes, 30 seconds

🌍 TIMEZONE CONVERSIONS:
   UTC: 2024-12-25 15:00:00 +0000 UTC
   New York: 2024-12-25 10:00:00 -0500 EST
   London: 2024-12-25 15:00:00 +0000 GMT
   Tokyo: 2024-12-26 00:00:00 +0900 JST

⏰ Reminders Set:
   ✓ 24 hours before
   ✓ 1 hour before
   ✓ 30 minutes before

🎯 Bonus Challenges:

Add recurring events (daily standup, weekly meeting)
Implement event conflict detection
Create a calendar view (monthly grid)
Add business hours calculation (skip weekends)
Export schedule to JSON/CSV
Implement event search and filtering

Share Your Solution! 💬

Built your event scheduler? Awesome! Share your implementation in the comments below. Did you add any creative features? How did you handle timezone edge cases? What's the most complex event scheduling problem you solved? Let's learn from each other! 🚀

Conclusion

And there we have it! Thanks for sticking around till the end. Your thoughts and ideas are super important to us. We’d absolutely love to hear what you think about today’s topic. Do you have any feedback, questions, or perhaps some extra tips to share? Don’t be shy! Please drop your comments and suggestions in the section below. Let’s keep this conversation going and learn from each other! Looking forward to reading your messages. ✨💬👇

Programming, Go, Date & Time, Time Management, Time Package, Time Zones

This post is licensed under CC BY 4.0 by the author.

20. Working with Time

What we will learn in this post?

⏰ Understanding Go’s `time` Package

🗓️ The `time.Time` Type

🚀 Current Time with `time.Now()`

🛠️ Making Specific Times with `time.Date()`

✨ Common Time Operations

🌊 Time Creation Flow

Go’s Time Magic: Formatting & Parsing! ⏰

🎨 Formatting Time with `Format()`

📜 Parsing Time with `Parse()`

🤔 Why the “Reference Time”?

A Quick Flow for Formatting 🌊

⏰ Understanding Go’s time.Duration

➕➖ Adding & Subtracting Durations

🕰️ Calculating Time Differences

🌟 Common Duration Constants

Mastering Go’s Time Utilities: Timers & Tickers ⏰

`time.Timer` for One-Time Delays ⏱️

`time.After()` for Quick Delays 🚀

`time.Ticker` for Repeated Actions 🔄

Preventing Leaks: The `Stop()` Method 🛑

Further Reading 📚

Blog: Understanding Go’s Timers and Tickers

🕰️ Mastering Go’s Time Zones

📍 What is `time.Location`?

🌐 Getting Your Time Zone Locations

🌍 Universal Time: `time.UTC`

🏡 Local System Time: `time.Local`

🗺️ Named Zones: `time.LoadLocation()`

🔄 Converting Times with `.In()`

💡 Practical Example

✨ How Time Zone Conversion Works

📚 Resources

🎮 Try It Live: Time Package Playground

🎯 Hands-On Assignment

Conclusion

Trending Tags

What we will learn in this post?

⏰ Understanding Go’s time Package

🗓️ The time.Time Type

🚀 Current Time with time.Now()

🛠️ Making Specific Times with time.Date()

✨ Common Time Operations

🌊 Time Creation Flow

Go’s Time Magic: Formatting & Parsing! ⏰

🎨 Formatting Time with Format()

📜 Parsing Time with Parse()

🤔 Why the “Reference Time”?

A Quick Flow for Formatting 🌊

⏰ Understanding Go’s time.Duration

➕➖ Adding & Subtracting Durations

🕰️ Calculating Time Differences

🌟 Common Duration Constants

Mastering Go’s Time Utilities: Timers & Tickers ⏰

time.Timer for One-Time Delays ⏱️

time.After() for Quick Delays 🚀

time.Ticker for Repeated Actions 🔄

Preventing Leaks: The Stop() Method 🛑

Further Reading 📚

Blog: Understanding Go’s Timers and Tickers

🕰️ Mastering Go’s Time Zones

📍 What is time.Location?

🌐 Getting Your Time Zone Locations

🌍 Universal Time: time.UTC

🏡 Local System Time: time.Local

🗺️ Named Zones: time.LoadLocation()

🔄 Converting Times with .In()

💡 Practical Example

✨ How Time Zone Conversion Works

📚 Resources

🎮 Try It Live: Time Package Playground

🎯 Hands-On Assignment

Conclusion

Trending Tags

⏰ Understanding Go’s `time` Package

🗓️ The `time.Time` Type

🚀 Current Time with `time.Now()`

🛠️ Making Specific Times with `time.Date()`

🎨 Formatting Time with `Format()`

📜 Parsing Time with `Parse()`

`time.Timer` for One-Time Delays ⏱️

`time.After()` for Quick Delays 🚀

`time.Ticker` for Repeated Actions 🔄

Preventing Leaks: The `Stop()` Method 🛑

📍 What is `time.Location`?

🌍 Universal Time: `time.UTC`

🏡 Local System Time: `time.Local`

🗺️ Named Zones: `time.LoadLocation()`

🔄 Converting Times with `.In()`