The question is not quite explicit, it can be interpreted in 2 ways, to one of which the answer is no, not possible; and the other to which the answer is yes, it's possible.
At runtime
If the type name is provided as a string
value, then at runtime it's not possible as types that are not referred to explicitly may not get compiled into the final executable binary (and thus obviously become unreachable, "unknown" at runtime). For details see Splitting client/server code. For possible workarounds see Call all functions with special prefix or suffix in Golang.
At "coding" time
If we're talking about "coding" time (source code writing / generating), then it's possible without creating / allocating a variable of the given type and calling reflect.TypeOf()
and passing the variable.
You may start from the pointer to the type, and use a typed nil
pointer value without allocation, and you can navigate from its reflect.Type
descriptor to the descriptor of the base type (or element type) of the pointer using Type.Elem()
.
This is how it looks like:
t := reflect.TypeOf((*YourType)(nil)).Elem()
The type descriptor t
above will be identical to t2
below:
var x YourType
t2 := reflect.TypeOf(x)
fmt.Println(t, t2)
fmt.Println(t == t2)
Output of the above application (try it on the Go Playground):
main.YourType main.YourType
true