How to resolve whether pass objects via interface{} have not initializated fields

I have problem with resolve whether object which was pass as interface to function hasn't initializated fields, like object which was defined as just someObject{} is a empty, because all fields, has value 0, or nil

Problem becomes more complicated if I pass diffrent objects, because each object have diffrent type field value so on this moment I don't find universal way to this.

Example

func main(){
	oo := objectOne{}
	ot := objectTwo{}
	oth := objectThree{"blah" , "balbal" , "blaal"}
	resolveIsNotIntialized(oo)
	resolveIsNotIntialized(ot)
	resolveIsNotIntialized(oth)
}

func resolveIsNotIntialized(v interface{}) bool{
	// and below, how resolve that oo and ot is empty
	if (v.SomeMethodWhichCanResolveThatAllFiledIsNotIntialized){
		return true
	}
	return false
}

I want to avoid usage switch statement like below, and additional function for each object, ofcorse if is possible.

func unsmartMethod(v interface{}) bool{
	switch v.(type){
	case objectOne:
		if v == (objectOne{}) {
		  return true
		}
		// and next object, and next....
	}
	return false
}

As Franck notes, this is likely a bad idea. Every value is always initialized in Go. Your actual question is whether the type equals its Zero value. Generally the Zero value should be designed such that it is valid. The better approach would generally be to create an interface along the lines of:

type ZeroChecker interface {
    IsZero() bool
}

And then attach that to whatever types you want to check. (Or possibly better: create an IsValid() test instead rather than doing your logic backwards.)

That said, it is possible to check this with reflection, by comparing it to its Zero.

func resolveIsNotIntialized(v interface{}) bool {
	t := reflect.TypeOf(v)
	z := reflect.Zero(t).Interface()
	return reflect.DeepEqual(v, z)
}

(You might be able to get away with return v == z here; I haven't thought through all the possible cases.)

I don’t think there is a good reason (in idiomatic Go) to do what you are trying to do. You need to design your structs so that default values (nil, empty string, 0, false, etc.) are valid and represent the initial state of your object. Look at the source of the standard library, there are lots of examples of that.
<br>What you are suggesting is easily doable via Reflection but it will be slow and clunky.

You could narrow the type which your function takes as an argement a little, not take an interface{} but accept one that allows you to check for non-zero values, say type intercae{nonZero() bool} as in the example code below. This will not tell you explicitly that it hasn't been set to the zero value, but that it is not zero.

type nonZeroed interface {
	nonZero() bool
}

type zero struct {
	hasVals bool
}

func (z zero) nonZero() bool {
	return z.hasVals
}

type nonZero struct {
	val int
}

func (nz nonZero) nonZero() bool {
	return nz.val != 0
}

type alsoZero float64

func (az alsoZero) nonZero() bool {
	return az != 0.0
}

func main() {
	z := zero{}
	nz := nonZero{
		val: 1,
	}
	var az alsoZero
	fmt.Println("z has values:", initialized(z))
	fmt.Println("nz has values:", initialized(nz))
	fmt.Println("az has values:", initialized(az))
}

func initialized(a nonZeroed) bool {
	return a.nonZero()
}

Obviously as the type get more complex additional verification would need to be made that it was "nonZero". This type of pattern could be used to check any sort condition.