在Go的struct字段中为非原始类型使用指针更好吗

I am going on a project which process some data, I am wondering that if it is better to use pointer in non-primitive typed fields of struct.

What I've found is that the reason of using pointer is that nil can be used as a zero-value, is this the only reason to use pointer?

For example, I am going to store time.Time in my struct and it cannot be nil, then is it better to use non-pointer field?

So is it okay to use

type A struct {
   CreatedAt   time.Time
}

rather than

type A struct {
    CreatedAt   *time.Time
}

when Now is not going to be nil?

I'm not really a professional or know the ins and outs of Go, so take everything I say with some grain of salt.

But as I am understanding it, you should most likely use pointers.

This is because every time you use a non-pointer type, the whole struct will be part of your struct in memory. As a consequence, you can't share a single instance of a struct between multiple structs - every single one gets a copy of your original struct.

Heres a small example:

// This struct has 2x64 bits in size
type MyStruct struct {
    A uint64
    B uint64
}

// This struct has 32 + 2x64 bits in size
type MyOtherStruct struct {
    C uint32
    Parent MyStruct
}

// This struct has 32 + the length of an address bits size 
type MyPointerStruct struct {
    D uint32
    Parent *MyStruct
}

But apart from memory concerns, there is also a performance hit if your inner struct is very big. Because every time you set the inner struct the whole memory has to be copied to your instance.

However you have to be careful if your are dealing with interfaces or structs. At runtime, an interface is represented as a type with two fields: A reference to the actual (runtime) type and one with a reference to the actual instance.

So I - with my unprofessional opinion - would recommend to not use pointers if you have interface types because otherwise the CPU has to deference twice (once to get the interface reference, and then again to get the instance of the interface).

Not sure I understand the question. In the case of "Now" I would make it a function of the struct i.e.:

type A struct{}

func (a A) Now() time.Time { return time.Now(); }

otherwise what does Now mean? Now is constantly changing.

There are great blogs on when to use pointers

The short would be it doesn't really depend on if the value can be nil, but more on memory and concurrency. Pointers will be passed as references, so less memory, and faster, but also means that changing in one go routine can be very dangerous because the value could be referenced in another go routine and cause race conditions and unexpected behaviors.