What is Reflection in Go?

Explore the concept of Reflection in the Go programming language , diving into its powerful capabilities for dynamic code editing and analysis.

What is Reflection in Go? Picture 1

The Go programming language is famous for its expressive capabilities. It is a powerful styling language that still gives applications the ability to flexibly edit and inspect objects including variables, functions, and types at runtime.

Reflection is the mechanism Go uses to perform this function. So what is Reflection in Go? How can reflection be introduced into Go applications?

What is reflection?

Reflection is the feature of a program that examines its variables and structures and manipulates them at runtime.

Reflection in Go is a language mechanism that provides dynamic type and object manipulation. You may need to inspect objects, update them, call methods, even implement native operations with their types without having to know the corresponding type at compile time. Reflection makes all of the above happen.

Various packages in Go include encoding, which allows you to work with JSON, and fmt, which rely heavily on internal reflection to perform their tasks.

Things to know about the reflect package in Go

Learning Golang can be challenging because of its powerful semantics and library of packages and methods that facilitate efficient software development.

Package reflect is one of the above packages. It contains all the methods you need to implement reflection in Go applications.

To get started with the reflect package, simply import it like this:

import "reflect"

The package defines two main types that lay the foundation for reflection in Go: reflect.Type and reflect.Value .

A Type is simply a Go type. reflect.Type is an interface that includes various methods for defining different types and examining their composition.

This function checks the type of any object in Go, reflect.TypeOf , accepts any value (an interface{} ) as the only argument and returns a reflect.Type value that represents the dynamic type of the object that statue.

The code below illustrates how to use reflect.TypeOf :

x := "3.142" y := 3.142 z := 3 typeOfX := reflect.TypeOf(x) typeOfY := reflect.TypeOf(y) typeOfZ := reflect.TypeOf(z) fmt.Println(typeOfX, typeOfY, typeOfZ) // string float64 int

The second type in the reflect package , reflect.Value can contain a value of any type. The function reflect.ValueOf accepts any interface{} and returns the interface's dynamic value.

Here's an example of how to use reflect.ValueOf to test the above values:

valueOfX := reflect.ValueOf(x) valueOfY := reflect.ValueOf(y) valueOfZ := reflect.ValueOf(z) fmt.Println(valueOfX, valueOfY, valueOfZ) // 3.142 3.142 3

To check the type and type of a value, you can use the Kind and Type methods like this:

typeOfX2 := valueOfX.Type() kindOfX := valueOfX.Kind() fmt.Println(typeOfX2, kindOfX) // string string

Although the results of both function calls are the same, they are completely different. typeOfX2 is essentially the same as typeOfX because both are reflect.Type values , but kindOfX is a constant, whose value is a specific type of x , string .

This is why there are a finite number of types like int, string, float, array…, but there are an infinite number of different user-defined types.

interface{} and reflect.Value work almost the same, they can contain values ​​of any type.

The difference between them lies in how an empty interface{} never exposes the operations and methods of the value they hold. Therefore, most of the time you need to know the dynamic type of the value and use type assertions to access it before you can perform operations on it.

In contrast, reflect.Value has methods that you can use to inspect its content and properties without having to worry about the type. The next section empirically examines these two types and shows their benefits in programs.

Implement Reflection in a Go program

Reflection is very broad and can be used in a program at any time. Below are some practical examples, illustrating how to use reflection in the program:

1. Double check the balance : Package reflect provides the DeepEqual function to check the value of two objects in depth of balance. For example, two structs are exactly equal if all their corresponding fields have the same type and value. Sample code:

// deep equality của hai mảng arr1 := [.]int{1, 2, 3} arr2 := [.]int{1, 2, 3} fmt.Println(reflect.DeepEqual(arr1, arr2)) // true

1. Copy slices and arrays : You can also use Go's reflection API to copy the contents of one slice or array into another array. Here's how:

 slice1 := []int{1, 2, 3} slice2 := []int{4, 5, 6} reflect.Copy(reflect.ValueOf(slice1), reflect.ValueOf(slice2)) fmt.Println(slice1) // [4 5 6]

1. Defining generic functions : Languages ​​like TypeScript provide a generic type, any , that you can use to hold variables of any type. Go doesn't have a built-in generic type, but you can use reflection to define generic functions. For example:

 // In kiểu của giá trị bất kỳ func printType(x reflect.Value) { fmt.Println("Value type:", x.Type()) }

1. Accessing struct tags : Tags are used to add metadata to Go struct fields, and many libraries use them to define and manipulate the behavior of each field. You can only access tag structs with reflection. The following sample code illustrates this:

 type User struct { Name string `json:"name" required:"true"` } user := User{"John"} field, ok := reflect.TypeOf(user).Elem().FieldByName("Name") if !ok { fmt.Println("Field not found") } // in toàn bộ tag và giá trị của "required" fmt.Println(field.Tag, field.Tag.Get("required")) // json:"name" required:"true" true

When to use Reflection and what applications are recommended

1. You should only use reflection when you cannot decide in advance the type of an object in the program.
2. Reflection can reduce application performance, so you should avoid using it for performance-critical operations.
3. Reflection can affect code readability, so you should avoid overusing it.
4. With reflection, errors are not logged at compile time, so you can expose your application to more errors at runtime.

Reflection is available in many languages ​​including C# and JavaScript. Go implements AI very well. The main advantage of reflection in Go is that you can solve problems with less code when exploiting the capabilities of this library.

Marvin Fry

Update 20 October 2023