Handy GoLang Date Time Snippets

1. Getting the Current Date and Time

currentTime := time.Now()
fmt.Println("Current Time:", currentTime)
// Output: Current Time: 2024-08-10 14:30:05.123456789 +0000 UTC m=+0.000000001

Explanation: Retrieves the current date and time including nanoseconds, in the local time zone. The output includes the year, month, day, hour, minute, second, and nanosecond precision, along with the time zone information.

2. Formatting Date and Time

formattedTime := time.Now().Format("2006-01-02 15:04:05")
fmt.Println("Formatted Time:", formattedTime)
// Output: Formatted Time: 2024-08-10 14:30:05

Explanation: Converts the current date and time into a string using a specific layout. The layout 2006-01-02 15:04:05 is the reference time in Go (January 2, 2006 at 15:04:05), which defines the format.

3. Parsing a Date String into Time

timeStr := "2024-08-10 12:00:00"
parsedTime, err := time.Parse("2006-01-02 15:04:05", timeStr)
if err != nil {
    fmt.Println("Error parsing time:", err)
}
fmt.Println("Parsed Time:", parsedTime)
// Output: Parsed Time: 2024-08-10 12:00:00 +0000 UTC

Explanation: Converts a date and time string into a time.Time object using a specified format layout. The layout must match the format of the input string. Here, "2024-08-10 12:00:00" is parsed using the layout "2006-01-02 15:04:05".

Note that in layout, the first argument to time.Parse function, the reference time is predefined and explained in this quote:

Format returns a textual representation of the time value formatted according to layout, which defines the format by showing how the reference time, defined to be Mon Jan 2 15:04:05 -0700 MST 2006 would be displayed if it were the value; it serves as an example of the desired output. The same display rules will then be applied to the time value.

4. Adding Days to a Date

currentTime := time.Now()
futureTime := currentTime.AddDate(0, 0, 5) // Adds 5 days
fmt.Println("Future Time:", futureTime)
// Output: Future Time: 2024-08-15 14:30:05.123456789 +0000 UTC m=+432000.000000001

Explanation: Adds 5 days to the current date and time using AddDate(years, months, days). Here, 0, 0, 5 indicates adding 0 years, 0 months, and 5 days to the current date. (Hint: To subtract days, use a negative value like -5.)

5. Adding Hours to a Date

currentTime := time.Now()
futureTime := currentTime.Add(10 * time.Hour)
fmt.Println("Future Time:", futureTime)
// Output: Future Time: 2024-08-10 24:30:05.123456789 +0000 UTC m=+36000.000000001

Explanation: Adds 10 hours to the current time using the Add method. The time.Hour constant represents one hour, so 10 * time.Hour adds 10 hours. (Hint: To subtract hours, use a negative value like -5 * time.Hour.)

6. Getting the Difference Between Two Dates

// time.Date(year, month, day, hour, minute, second, nanosecond, location)
time1 := time.Date(2024, 8, 10, 12, 0, 0, 0, time.UTC)
time2 := time.Date(2024, 8, 15, 12, 0, 0, 0, time.UTC)
duration := time2.Sub(time1)
fmt.Println("Difference in Days:", duration.Hours()/24)
// Output: Difference in Days: 5

Explanation: Calculates the difference between two dates using the Sub method, which returns a Duration. The difference is then converted to days by dividing the duration in hours by 24.

7. Comparing Dates: Before and After

time1 := time.Date(2024, 8, 10, 12, 0, 0, 0, time.UTC)
time2 := time.Date(2024, 8, 15, 12, 0, 0, 0, time.UTC)

isBefore := time1.Before(time2)
isAfter := time2.After(time1)

fmt.Println("Is time1 before time2?", isBefore)
fmt.Println("Is time2 after time1?", isAfter)
// Output: 
// Is time1 before time2? true
// Is time2 after time1? true

Explanation: Checks if one date is before or after another date using the Before and After methods, both of which return boolean values.

8. Creating a Date from Year, Month, Day

date := time.Date(2024, time.August, 10, 0, 0, 0, 0, time.UTC)
fmt.Println("Created Date:", date)
// Output: Created Date: 2024-08-10 00:00:00 +0000 UTC

Explanation: Creates a specific date by specifying the year, month, day, hour, minute, second, nanosecond, and time zone. Here, the date is set to August 10, 2024, at midnight UTC.

9. Extracting the Year, Month, Day from a Date

year, month, day := time.Now().Date()
fmt.Printf("Year: %d, Month: %s, Day: %d\n", year, month, day)
// Output: Year: 2024, Month: August, Day: 10

Explanation: Extracts the year, month, and day components from the current date using the Date method.

10. Extracting the Hour, Minute, Second from a Time

hour, minute, second := time.Now().Clock()
fmt.Printf("Hour: %d, Minute: %d, Second: %d\n", hour, minute, second)
// Output: Hour: 14, Minute: 30, Second: 5

Explanation: Extracts the hour, minute, and second components from the current time using the Clock method.

11. Getting the Current Time in UTC

utcTime := time.Now().UTC()
fmt.Println("Current Time in UTC:", utcTime)
// Output: Current Time in UTC: 2024-08-10 14:30:05.123456789 +0000 UTC

Explanation: Converts the current local time to UTC (Coordinated Universal Time) using the UTC method.

12. Converting UTC Time to Local Time

utcTime := time.Now().UTC()
localTime := utcTime.Local()
fmt.Println("Local Time:", localTime)
// Output: Local Time: 2024-08-10 10:30:05.123456789 -0400 EDT

Explanation: Converts a UTC time to the local time zone using the Local method, adjusting the time according to the local time zone offset.

13. Parsing Time in a Different Time Zone

timeStr := "2024-08-10 12:00:00"
location, _ := time.LoadLocation("America/New_York")
parsedTime, err := time.ParseInLocation("2006-01-02 15:04:05", timeStr, location)
fmt.Println("Parsed Time in New York:", parsedTime)
// Output: Parsed Time in New York: 2024-08-10 12:00:00 -0400 EDT

Explanation: Parses a date string in a specified time zone using ParseInLocation, which requires the time format, the time string, and the location. This example converts the time string into the time in New York.

14. Calculating the Beginning of the Week

currentTime := time.Now()
weekday := currentTime.Weekday()
startOfWeek := currentTime.AddDate(0, 0, -int(weekday))
fmt.Println("Start of the Week:", startOfWeek)
// Output: Start of the Week: 2024-08-04 14:30:05.123456789 +0000 UTC

Explanation: Calculates the start of the current week (Sunday) by subtracting the number of days since the beginning of the week from the current date.

15. Calculating the Time Until a Specific Date

futureTime := time.Date(2024, 12, 31, 0, 0, 0, 0, time.UTC)
duration := time.Until(futureTime)
fmt.Printf("Time until New Year: %v\n", duration)
// Output: Time until New Year: 5094h29m54.876543211s

Explanation: Calculates the duration until a specific future date using the Until function, which returns a Duration representing the time remaining.

16. Checking if a Year is a Leap Year

year := 2024
isLeapYear := time.Date(year, 2, 29, 0, 0, 0, 0, time.UTC).Day() == 29
fmt.Printf("Is %d a leap year? %v\n", year, isLeapYear)
// Output: Is 2024 a leap year? true

Certainly! Let's continue from where we left off and add snippets for converting to and from Unix time, including examples for seconds, microseconds, and nanoseconds.

17. Converting Time to Unix Timestamp (Seconds)

currentTime := time.Now()
unixTimestamp := currentTime.Unix()
fmt.Println("Unix Timestamp (Seconds):", unixTimestamp)
// Output: Unix Timestamp (Seconds): 1723319405

Explanation: Converts the current time to a Unix timestamp, represented as the number of seconds that have elapsed since January 1, 1970 (the Unix epoch).

18. Converting Unix Timestamp (Seconds) to Time

unixTimestamp := int64(1723319405)
timeFromUnix := time.Unix(unixTimestamp, 0)
fmt.Println("Time from Unix Timestamp:", timeFromUnix)
// Output: Time from Unix Timestamp: 2024-08-10 14:30:05 +0000 UTC

Explanation: Converts a Unix timestamp in seconds back to a time.Time object. The second argument (0) is the nanosecond part, which is not used here.

19. Converting Time to Unix Timestamp (Microseconds)

currentTime := time.Now()
unixMicroseconds := currentTime.UnixMicro()
fmt.Println("Unix Timestamp (Microseconds):", unixMicroseconds)
// Output: Unix Timestamp (Microseconds): 1723319405123456

Explanation: Converts the current time to a Unix timestamp in microseconds. This provides higher precision than seconds but less than nanoseconds.

20. Converting Unix Timestamp (Microseconds) to Time

unixMicroseconds := int64(1723319405123456)
timeFromUnixMicro := time.Unix(0, unixMicroseconds*1000)
fmt.Println("Time from Unix Microseconds:", timeFromUnixMicro)
// Output: Time from Unix Microseconds: 2024-08-10 14:30:05.123456 +0000 UTC

Explanation: Converts a Unix timestamp in microseconds back to a time.Time object. The first argument is the seconds part (0 here), and the second argument is the nanoseconds, obtained by multiplying microseconds by 1000.

21. Converting Time to Unix Timestamp (Nanoseconds)

currentTime := time.Now()
unixNanoseconds := currentTime.UnixNano()
fmt.Println("Unix Timestamp (Nanoseconds):", unixNanoseconds)
// Output: Unix Timestamp (Nanoseconds): 1723319405123456789

Explanation: Converts the current time to a Unix timestamp in nanoseconds. This provides the highest precision for representing time.

22. Converting Unix Timestamp (Nanoseconds) to Time

unixNanoseconds := int64(1723319405123456789)
timeFromUnixNano := time.Unix(0, unixNanoseconds)
fmt.Println("Time from Unix Nanoseconds:", timeFromUnixNano)
// Output: Time from Unix Nanoseconds: 2024-08-10 14:30:05.123456789 +0000 UTC

Explanation: Converts a Unix timestamp in nanoseconds back to a time.Time object. The first argument is the seconds part (0 here), and the second argument is the nanoseconds directly.

23. Profiling Execution Time

Snippet 1: Measuring Function Execution Time

start := time.Now() // Start timing
longRunningTask()
duration := time.Since(start) // Calculate duration
fmt.Printf("Execution time: %v\n", duration)
// Output: Execution time: 2.000123456s

Explanation: Captures the start time before executing a function (longRunningTask). After the function completes, time.Since(start) computes the duration elapsed since the start, providing the total execution time.

Snippet 2: Using defer to Automatically Measure Execution Time

func measureExecutionTime(start time.Time) {
    duration := time.Since(start)
    fmt.Printf("Execution time: %v\n", duration)
}

func longRunningTask() {
    defer measureExecutionTime(time.Now()) // Measure execution time
    time.Sleep(2 * time.Second) // Simulates a long task
}

Explanation: Utilizes defer to automatically call measureExecutionTime when longRunningTask finishes. time.Now() captures the start time, and defer ensures that measureExecutionTime runs at the end of the function, measuring how long the task took to complete.