Working with Dates and Time in Go


Any programming language utilizing dates and time has some inherent complexity related to it. Dealing with these knowledge sorts shouldn’t be like utilizing another sorts due to the dependency or the references they comply with. For instance, Go follows the kind for time, which begins with 1st January 1970 at 00 hour, 00 minutes and 00 second UTC. This is named UNIX epoch. To higher perceive this knowledge sort, let’s dive into the intricacies of Unix epoch earlier than studying the way to work with the related Go APIs used for working with dates and time.

What’s the UNIX epoch in Go Programming?

The Go programming language follows the UNIX epoch, starting with January 1, 1970 at 00:00:00 UTC. UNIX retains observe of the time by counting the variety of seconds since this special occasion. The counter for the variety of seconds elapsed is saved in a 32-bit integer and the utmost quantity that may be saved in a 32-bit integer is 2,147,483,647. Since, in computing, numbers have a binary illustration (binary encoding), this most worth is represented with 31, 1’s. Observe additionally that, since it’s an integer, it may be each unfavorable and optimistic. Subsequently, half of the encoded numbers can be optimistic and the opposite half can be unfavorable numbers. That is made potential by representing the primary binary digit as sign-bit, which merely means numbers starting with 0 are optimistic and a quantity starting with 1 is unfavorable. However the query is: why do we’d like unfavorable numbers if we merely need to depend ahead the variety of seconds elapsed because the special occasion?

Learn: Understanding Mathematical Operators in Go

Why Do We Want Signed Integers?

Signed integers are used as a result of a date earlier than the special occasion (Jan 1, 1970) is represented by a unfavorable integer, and the date after is represented with a optimistic integer. Subsequently, a second depend, resembling 100, means 100 seconds earlier than UNIX epoch and +100 would imply a 100-second depend after UNIX epoch. Consider the quantity line: optimistic strikes ahead and unfavorable strikes again from 0 (on this case from 1-1-1970, 00:00:00 UTC).

The Millenium Bug

Once we determine to symbolize time with a 32-bit integer, the utmost worth – or the utmost second depend – could be 2147483647. Now, if we translate that into years, months and days in a human comprehensible type, the date we get is nineteenth Jan 2038 at round 3:14:08 am. So, that is the utmost date we get with a 32-bit integer.

Now, what occurs to any system that makes use of such a clock – the place one second after the date and time represented by the utmost 32-bit worth goes from a most signal bit integer to a bit illustration and the place the primary signal bit 1 is adopted by 31 0s? The clock appears to reset again to a quantity which, when transformed to a date format, turns into thirteenth December Friday 1901. This merely signifies that the subsequent tick after nineteenth Jan 2038, 03:14:08 can be thirteenth Dec, 1901. That is the mess behind the notorious “Millenium bug”.

The Answer to the Millenium Bug

Builders could recall the Y2K bug – though an issue, no programs crashed because of this, regardless of the entire apocalyptic expectations. Regardless of the shortage of system crashes, the issue is sort of actual and was, fortuitously, solved efficiently. This downside goes to pop up as soon as once more with the Unix epoch, however we’ve got a while till 2038 to repair it. The bug could be patched up quickly by utilizing an even bigger quantity. In some unspecified time in the future in time, this downside will pop up once more. An answer is to make use of 64-bit integers moderately than 32-bit.

Even nonetheless, a 64-bit – or perhaps a 128-bit quantity – is however a brief answer for the issue and solely serves to purchase us a while till the subsequent “Millennium bug”. Simply to provide you an thought, this 64-bit quantity will run out on 4th Dec 3:30pm, yr 292277026596 AD. So we’ll get some earlier than the subsequent “Millennium bug” hits!

Now that we’ve got lined what the Unix epoch is, why Go builders want signed integers, what causes “Millennium bugs”, and their momentary options, let’s return to studying concerning the date and time API in Go.

Learn: Easy methods to Deal with Errors in Go

Working with The time Package deal in Go

Though Go makes use of the UNIX notion of time, for all sensible functions the time interval utilized by the Go API is in nanoseconds. The distinction between time and time interval is that point represents a selected level within the Epoch and will depend on issues like time zone and it is not sensible in isolation. Time interval, however, is a amount or a quantity that can be utilized individually.

The time bundle features a sort known as Period, which represents the elapsed time between two instants as an int64 nanosecond depend. The biggest illustration depend is roughly 290 years. Observe, nevertheless, that the Time sort represents an instantaneous (or mounted level) in time with nanosecond precision.

The Time Sort in Go

The next code snippet reveals the way to discover the variety of seconds elapsed because the Epoch utilizing the Go programming language:

fmt.Printf("npercentd seconds elapsed since UNIX epoch (1970, Jan 1; 00:00:00)", time.Now().Unix())
fmt.Printf("npercentd nanoseconds elapsed since UNIX epoch (1970, Jan 1; 00:00:00)", time.Now().UnixNano())

Observe that Now() is a handy operate offered by the time bundle. This operate returns a construction sort known as Time, which not solely encapsulates the time but in addition the timezone. The Time construction offers quite a lot of strategies for use with respect to the time knowledge sort. Here’s a fast instance exhibiting the way to discover the approximate age of an individual, given a delivery date, utilizing Golang:

bundle most important

import (

func most important() {
bdate := time.Date(1980, time.Month(2), 16, 0, 0, 0, 0, time.UTC)
cdate := time.Now()
y, m, d := calcAge(bdate, cdate)
fmt.Printf("%d years, %d months %d days", y, m, d)

func calcAge(bdate, cdate time.Time) (int, time.Month, int) {
if cdate.Yr() < bdate.Yr() {
return -1, -1, -1
by, bm, bd := bdate.Date()
cy, cm, cd := cdate.Date()
if cd < bd {
cd += 30
if cm < bm {
cm += 12
return cy - by, cm - bm, cd - bd

Operating this code in your built-in growth setting (IDE) or code editor will end result within the following output:

41 years, 11 months 21 days

Learn: Strategies in Go Defined

Formatting and Parsing Dates in Go

The Format() technique returns a textual content illustration of time knowledge. Given a structure, the date and time could be formatted in line with the necessity. For instance, it’s potential to supply a sample when changing time to a string worth, as proven right here:

dt := time.Now()
fmt.Printf("npercents", dt.Format("2006:01:01"))

The above code prints the date output utilizing a colon (:) because the separator. If we need to print a 12-hour time format we’d write:

fmt.Printf("npercents", dt.Format(time.Kitchen))

The Go programming language offers quite a lot of constants that can be utilized as layouts when formatting time values. The fixed, time.Kitchen is considered one of them. Take a look at the official Go time bundle documentation for different such constants.

Now, if Go builders need to parse a date from a string worth, they will use the Parse() operate. This operate helps in setting up a Time construction from a string in line with a specified format. Right here is how that appears in code:

str := "Jan 2, 2006 at 3:04pm (MST)"
t, err := time.Parse(str, "Feb 4, 2014 at 6:05pm (PST)")
if err != nil {

Discovering Time Distinction with Go

If we’ve got two time values, the only technique to discover the distinction between them is by changing them to UNIX instances after which performing the calculation. Suppose we need to discover the length of time taken by a operate execution. We are able to seize the time snapshot as soon as in the beginning of the operate name after which once more after the operate returns to the caller. The time distinction will present the length it took to execute the operate. Right here is an instance of the way to code this in Go:

bundle most important

import (

func most important() {

t1 := time.Now()
t2 := time.Now()
fmt.Printf("npercentd seconds distinction.", t2.Unix()-t1.Unix())
fmt.Printf("npercents distinction", t2.Sub(t1))


func getFibonacciNum(max int) int {
a := 0
b := 1
var c int
if max < 1 {
return -999
if max == 1 {
return 0
if max == 2 {
return 1
for i := 2; i < max; i++ {
c = a + b
a = b
b = c
return c

Right here is the output of the above code:

0 seconds distinction.
17.798µs distinction

Remaining Ideas on Working with Dates and Time in Go

The primary downside with working with time values is that they’re fairly advanced to keep up. As talked about on this Go programming tutorial, the issue with the UNIX Epoch is the restrictions on dimension for 32-bit integers, which ends up in “Millennium bugs.” Additional, there are time zones and several types of calendars used everywhere in the world that additional complicate the problem. The Go API offers ample features to work with dates and instances within the Golang language. Right here, we demonstrated a number of of them. Keep tuned for extra!

Learn extra Go and Golang programming tutorials.


Please enter your comment!
Please enter your name here