- Trending Categories
Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
How to find the type of Struct in Golang?
In Golang, structs are a powerful and essential feature that helps in organizing data and improving code readability. A struct is a composite data type that groups together zero or more values of different types. It is a user-defined type that can be customized according to the programmer's needs. Sometimes, when working with large codebases, it can become difficult to keep track of the different types of structs being used. In this article, we will discuss how to find the type of struct in Golang.
Using the "reflect" Package
The "reflect" package in Golang provides a way to inspect types at runtime. We can use the "reflect.TypeOf()" function to determine the type of a struct. This function takes an interface{} as an argument and returns a Type object that represents the dynamic type of the value passed to it.
Example
Here's an example −
package main
import (
"fmt"
"reflect"
)
type Person struct {
Name string
Age int
}
func main() {
p := Person{Name: "John", Age: 30}
t := reflect.TypeOf(p)
fmt.Println(t)
}
Output
main.Person
Using the "%T" Format Specifier
Another way to find the type of a struct is to use the "%T" format specifier. This specifier can be used with the fmt.Printf() function to print the type of the value passed to it.
Example
Here's an example −
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
p := Person{Name: "John", Age: 30}
fmt.Printf("Type of p: %T", p)
}
Output
Type of p: main.Person
Using The "go/types" Package
The "go/types" package in Golang provides a way to inspect types in a program statically. This package is particularly useful for analyzing Go code and finding the types of structs used in a program.
Example
Here's an example −
package main
import (
"go/types"
"golang.org/x/tools/go/packages"
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
cfg := &packages.Config{Mode: packages.LoadAllSyntax}
pkgs, _ := packages.Load(cfg, ".")
for _, pkg := range pkgs {
for _, file := range pkg.Syntax {
for _, decl := range file.Decls {
switch decl := decl.(type) {
case *types.GenDecl:
for _, spec := range decl.Specs {
if ts, ok := spec.(*types.TypeSpec); ok {
if _, ok := ts.Type.(*types.Struct); ok {
fmt.Printf("Found struct %s\n", ts.Name())
}
}
}
}
}
}
}
}
This program uses the "go/types" package to find all the structs used in the current package. The program first loads all the Go source files in the package and then iterates over each file, looking for declarations that contain type specifications. If a type specification is found, the program checks if the type is a struct and prints its name.
Conclusion
In this article, we have discussed three different ways to find the type of a struct in Golang. The "reflect" package provides a way to inspect types at runtime, while the "%T" format specifier can be used to print the type of a value. The "go/types" package is particularly useful for analyzing Go code and finding the types of structs used in a program
1K+ Views
