Deep Dive Into Go “reflect” Package
Tags: reflections, go
Published: 2022-12-27 10:44:31

---
title: Deep Dive Into Go “reflect” Package
published: true
date: 2022-12-27 10:38:28 UTC
tags: reflections,golang
canonical_url: 
---

![](https://cdn-images-1.medium.com/max/1024/1*_T4AEQ5b00TzHkOlPV8HIw.png)

The reflect package in Go is a powerful tool for inspecting and manipulating the runtime behavior of Go programs. It allows developers to examine the type, value, and other characteristics of variables and expressions at runtime, as well as modify the value of variables and call functions using reflection.

The reflect package is part of the standard library and is imported with the following statement:

```
import "reflect"
```

### Value and Type

At the core of the reflect package are the Value and Type types. A Value represents a value in Go, and a Type represents a type in Go. These types are used to represent the runtime behavior of variables and expressions, and provide a way to manipulate them using reflection.

To obtain a Value for a variable or expression, you can use the reflect.ValueOf() function. This function takes an interface{} value as an argument and returns a Value that represents the value of the interface{}. For example:

```
x := 123
val := reflect.ValueOf(x)
```

To obtain the Type of a value, you can use the Type() method on a Value. This method returns a Type that represents the type of the value. For example:

```
typ := val.Type()
```

### Kind

The Kind of a Value or Type represents the underlying kind of the value or type. It can be one of the following constants:

- Bool: a boolean value
- Int, Int8, Int16, Int32, Int64: an integer value
- Uint, Uint8, Uint16, Uint32, Uint64, Uintptr: an unsigned integer value
- Float32, Float64: a floating-point value
- Complex64, Complex128: a complex number
- Array: an array
- Chan: a channel
- Func: a function
- Interface: an interface
- Map: a map
- Ptr: a pointer
- Slice: a slice
- String: a string
- Struct: a struct
- UnsafePointer: an unsafe pointer

You can obtain the Kind of a Value or Type by using the Kind() method. For example:

```
kind := val.Kind()
```

### Manipulating Values

Once you have a Value representing a value, you can use various methods to manipulate it. For example, you can use the Set() method to set the value of the Value:

```
val.Set(reflect.ValueOf(456))
```

You can also use the Elem() method to obtain a Value that represents the value pointed to by a pointer Value:

```
ptr := reflect.ValueOf(&x)
elem := ptr.Elem()
elem.Set(reflect.ValueOf(789))
```

### Calling Functions

The reflect package also allows you to call functions using reflection. To call a function using reflection, you first need to obtain a Value representing the function using the ValueOf() function. Then, you can use the `Call()` method on the Value to call the function. The Call() method takes a slice of Values as arguments, representing the arguments to the function, and returns a slice of Values representing the return values of the function.

For example, consider the following function:

```
func add(x int, y int) int {
 return x + y
}
```

To call this function using reflection, you can do the following:

```
funcVal := reflect.ValueOf(add)
args := []reflect.Value{reflect.ValueOf(1), reflect.ValueOf(2)}
result := funcVal.Call(args)
```

The result variable will be a slice of Values containing a single Value, which represents the return value of the add() function.

### Type Assertions

The reflect package also provides a way to perform type assertions on values using the TypeAssert() method on a Value. This method takes an interface{} value as an argument and attempts to assign the value of the Value to the interface{}. If the types are compatible, it returns a Value representing the value of the interface{} and a boolean value indicating success. If the types are not compatible, it returns the zero Value and false.

For example:

```
val := reflect.ValueOf("hello")
str, ok := val.TypeAssert(reflect.TypeOf(""))
if ok {
 fmt.Println(str)
}
```

This code will print “hello” to the console because the value of val is a string and the interface{} value passed to TypeAssert() is a string.

### Iterating Over Struct Fields

The reflect package also provides a way to iterate over the fields of a struct using the Type() and NumField() methods on a Value. The Type() method returns a Type representing the type of the value, and the NumField() method returns the number of fields in the struct. You can then use the Field() method to obtain a Value representing a particular field in the struct.

For example:

```
type User struct {
 Name string
 Age int
}

user := User{Name: "Alice", Age: 30}
val := reflect.ValueOf(user)

for i := 0; i < val.NumField(); i++ {
 field := val.Field(i)
 fmt.Printf("%s: %v\n", val.Type().Field(i).Name, field.Interface())
}
```

This code will print the following to the console:

```
Name: Alice
Age: 30
```

One advanced use of the reflect package in Go is the ability to dynamically call methods on any object. This can be useful in situations where you want to call a method on an object, but the name of the method is not known until runtime.

To dynamically call a method on an object using reflection, you first need to obtain a Value representing the object. Then, you can use the MethodByName() method on the Value to obtain a Value representing the method. Finally, you can use the Call() method on the method Value to call the method.

Here is an example of how to dynamically call a method on an object using reflection:

```
type MyStruct struct {
}

func (m *MyStruct) Hello(name string) string {
 return "Hello, " + name
}

func main() {
 obj := MyStruct{}
 objVal := reflect.ValueOf(&obj)
 methodVal := objVal.MethodByName("Hello")
 args := []reflect.Value{reflect.ValueOf("Alice")}
 result := methodVal.Call(args)
 fmt.Println(result[0])
}
```

In this example, the Hello() method is called on the MyStruct object using reflection. The method takes a single string argument and returns a string. The MethodByName() method is used to obtain a Value representing the Hello() method, and the Call() method is used to call the method with the argument "Alice". The returned Value slice contains a single Value representing the return value of the method, which is then printed to the console.

This approach can be useful when you want to call a method on an object, but the name of the method is not known until runtime. It allows you to dynamically call any method on an object using reflection, as long as you know the name of the method and the arguments it expects.

Note that this approach is less efficient than calling the method directly, as it requires using reflection. Therefore, it should be used sparingly and only when necessary. In general, it is better to call methods directly whenever possible to avoid the overhead of using reflection.

### Conclusion

The reflect package in Go provides a powerful and flexible way to inspect and manipulate the runtime behavior of Go programs. It allows developers to examine the type and value of variables and expressions, modify their values, and call functions using reflection. By using the Value, Type, and Kind types, as well as the various methods provided by the reflect package, developers can perform a wide range of tasks using reflection in Go.