What Is the Zero Value of time.Time in Go?

By the end of this page, you will understand why time.Time cannot be nil, what its zero value is, how to return it from functions, and how to check whether a time.Time has been set in real Go programs.

In Go, every type has a zero value. This is the default value a variable gets when you declare it without explicitly assigning anything.

For example:

• int → 0
• string → ""
• bool → false
• pointers, slices, maps, functions, interfaces → nil

But time.Time is not a pointer. It is a struct type from Go's time package. Structs cannot be nil unless you use a pointer to them, such as *time.Time.

So the zero value of time.Time is simply:

time.Time{}

This represents the earliest representable time in Go's time.Time type:

0001-01-01 00:: + UTC

Think of a time.Time value like a printed form with date fields on it.

• A pointer can be nil, which is like saying: “there is no form at all.”
• A struct value like time.Time always exists as a full form.
• Its zero value is like a blank default form that has not been filled in with a real date.

So when you have a plain time.Time, you cannot say “no form” with nil. You can only use its default blank value:

time.Time{}

If you really need the idea of “no time at all,” then you can use a pointer:

var t *time.Time = nil

But in normal Go code, returning time.Time{} plus an error is usually the simplest and most idiomatic choice.

The core syntax is straightforward.

Zero value of time.Time

var t time.Time
fmt.Println(t)

Because t was declared but not assigned, it gets the zero value automatically.

Explicit zero value

zero := time.Time{}
fmt.Println(zero)

This creates the same zero value explicitly.

Returning zero value from a function

package main

import (
	"errors"
	"time"
)

func getTimestamp(ok bool) (time.Time, error) {
	if !ok {
		return time.Time{}, errors.New("timestamp not available")
	}

	return time.Now(), nil
}

Here:

• time.Now() is returned when successful
• time.Time{} is returned when there is an error

Checking whether a time is zero

Consider this example:

package main

import (
	"errors"
	"fmt"
	"time"
)

func parseDeadline(input string) (time.Time, error) {
	if input == "" {
		return time.Time{}, errors.New("empty deadline")
	}

	return time.Parse("2006-01-02", input)
}

func main() {
	deadline, err := parseDeadline("")
	fmt.Println("deadline:", deadline)
	fmt.Println("is zero:", deadline.IsZero())
	fmt.Println("error:", err)
}

What happens step by step

1. main() calls parseDeadline("").
2. Inside parseDeadline, the input is an empty string.
3. The condition input == "" is true.
4. The function returns:
   • time.Time{} as the zero time.Time

time.Time zero values appear in many practical Go programs.

1. Function results with errors

A function that fetches a timestamp from a database or API may return:

return time.Time{}, err

if the lookup fails.

2. Optional timestamps

You may have fields such as:

• CreatedAt
• UpdatedAt
• DeletedAt
• PublishedAt

A zero time.Time can mean the timestamp has not been set yet.

3. Form or config validation

If a date was not provided, a zero time.Time may represent “missing input” until validation decides whether that is allowed.

4. Scheduling systems

A job runner might use zero time to mean:

• never run
• not scheduled yet
• retry time not calculated yet

5. Parsing and transformation pipelines

When converting raw strings into typed data, zero time may temporarily represent an unset or failed value until errors are handled.

In real Go codebases, developers usually use time.Time in a few common patterns.

Guard clause with zero return

func startTimeFromConfig(cfg string) (time.Time, error) {
	if cfg == "" {
		return time.Time{}, errors.New("missing config value")
	}
	return time.Parse(time.RFC3339, cfg)
}

This is a classic guard clause: fail early, return the zero value, and report the error.

Validation with IsZero()

func canPublish(publishedAt time.Time) bool {
	return !publishedAt.IsZero()
}

This is clearer than comparing formatted strings or manually checking fields.

Optional field design

Sometimes developers choose between:

• time.Time when a value should always exist eventually
• *time.Time when nil should explicitly mean “missing” or “not set”

Here are common mistakes beginners make with time.Time.

Mistake 1: Returning nil for a non-pointer type

Broken code:

func getTime() (time.Time, error) {
	return nil, errors.New("failed")
}

Why it fails:

• time.Time is a struct, not a pointer
• only some types can be nil

Correct version:

func getTime() (time.Time, error) {
	return time.Time{}, errors.New("failed")
}

Mistake 2: Comparing to nil

Broken code:

var t time.Time
if t == nil {
	fmt.Println("unset")
}

Why it fails:

Here is how time.Time compares with related choices.

vs

// Zero value of time.Time
var t time.Time

// Explicit zero value
zero := time.Time{}

// Return zero value on error
return time.Time{}, err

// Check whether a time is zero
if t.IsZero() {
    // t has not been set
}

Rules to remember

• time.Time is a struct, so it cannot be nil
• *time.Time is a pointer, so it can be nil
• The zero value of time.Time is time.Time{}
• The printed zero time is usually 0001-01-01 00:00:00 +0000 UTC
• Use IsZero() to test for the zero value
• In (time.Time, error) functions, return time.Time{}, err on failure

Quick decision guide

• Need a normal timestamp value? Use time.Time
• Need to represent missing time with nil? Use *time.Time

Why can't I return nil for time.Time in Go?

Because time.Time is a struct value, not a pointer. Only certain types such as pointers, slices, maps, interfaces, channels, and functions can be nil.

What is the zero value of time.Time?

The zero value is:

time.Time{}

It prints as 0001-01-01 00:00:00 +0000 UTC.

How do I check if a time.Time is unset?

Use:

t.IsZero()

This is the standard and most readable approach.

Should I use time.Time{} or time.Now() as a default?

Use time.Time{} only when you mean “no real time set yet.” Use time.Now() when you want the current time.

When should I use *time.Time instead of time.Time?

• Zero values in Go — time.Time{} is part of Go's broader zero-value design.
• Structs in Go — understanding that time.Time is a struct explains why it cannot be nil.
• Pointers in Go — useful for learning when nil is possible, such as with *time.Time.
• Error handling in Go — many Go functions return a zero value plus an error.
• The time package — helps you work with parsing, formatting, durations, and timestamps.
• Method receivers in Go — IsZero() is a method on time.Time.
• Value types vs reference-like types — clarifies why some types can be nil and others cannot.