Skip to content

Reflection

Reflection in Go

Reflection in Go allows you to inspect and manipulate the types of objects at runtime. It is a powerful feature that can be used for tasks like serialization, logging, testing, and other meta-programming tasks. Reflection is implemented in Go via the reflect package.

Reflection is useful when you need to handle arbitrary types in a dynamic way, but it comes with a performance cost and reduces type safety, so it should be used carefully.

1. The reflect Package

The reflect package provides mechanisms to work with types and values at runtime. The two primary types in reflection are:

  • reflect.Type: Represents the type of a value.
  • reflect.Value: Represents the value of a variable.

2. Getting Type and Value with Reflection

To work with reflection, we typically use reflect.TypeOf() to get the type of an object and reflect.ValueOf() to get the value of an object.

Example: Using reflect.TypeOf() and reflect.ValueOf()

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x int = 42
    var y float64 = 3.14
    var s string = "Hello, reflection!"

    // Get type and value of variables
    fmt.Println("Type of x:", reflect.TypeOf(x))
    fmt.Println("Value of x:", reflect.ValueOf(x))

    fmt.Println("Type of y:", reflect.TypeOf(y))
    fmt.Println("Value of y:", reflect.ValueOf(y))

    fmt.Println("Type of s:", reflect.TypeOf(s))
    fmt.Println("Value of s:", reflect.ValueOf(s))
}

Output: 

Type of x: int
Value of x: 42
Type of y: float64
Value of y: 3.14
Type of s: string
Value of s: Hello, reflection!

3. Getting and Modifying Struct Fields Using Reflection

You can also manipulate struct fields using reflection. To do this, the struct must be passed by pointer to allow modifications.

Example: Accessing Struct Fields

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Alice", Age: 30}

    // Get type and value of the struct
    v := reflect.ValueOf(&p).Elem()
    t := v.Type()

    // Access struct fields by name
    for i := 0; i < v.NumField(); i++ {
        fmt.Printf("%s: %v\n", t.Field(i).Name, v.Field(i).Interface())
    }

    // Modify the fields using reflection
    v.FieldByName("Name").SetString("Bob")
    v.FieldByName("Age").SetInt(35)

    fmt.Println("Updated person:", p)
}

Output: 

Name: Alice
Age: 30
Updated person: {Bob 35}

  • Elem(): Dereferences the pointer to access the struct.
  • NumField(): Gets the number of fields in the struct.
  • Field(i): Gets a field by index.
  • SetString() and SetInt(): Used to modify the values of struct fields.

4. Reflection with Interfaces

You can use reflection with interfaces, but it's important to note that Go’s interface values can hold both the type and the value, so they require a bit more work to inspect.

Example: Working with Interface Values

package main

import (
    "fmt"
    "reflect"
)

func printTypeAndValue(i interface{}) {
    v := reflect.ValueOf(i)
    t := reflect.TypeOf(i)

    fmt.Println("Type:", t)
    fmt.Println("Value:", v)
}

func main() {
    var x int = 42
    var y string = "hello"

    printTypeAndValue(x)
    printTypeAndValue(y)
}

Output: 

Type: int
Value: 42
Type: string
Value: hello

  • reflect.ValueOf(): Gets the value of an interface.
  • reflect.TypeOf(): Gets the type of an interface.

5. Reflection and Interfaces with Method Invocation

You can also use reflection to invoke methods on structs.

Example: Calling Methods with Reflection

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
}

func (p Person) Greet() {
    fmt.Println("Hello, " + p.Name)
}

func main() {
    p := Person{Name: "Alice"}

    // Get value of the struct and method
    v := reflect.ValueOf(p)
    method := v.MethodByName("Greet")

    // Call method via reflection
    if method.IsValid() {
        method.Call(nil)
    } else {
        fmt.Println("Method not found!")
    }
}

Output: 

Hello, Alice

  • MethodByName(): Returns a method by name.
  • Call(): Invokes the method. If the method requires arguments, they can be passed as a slice of reflect.Value.

6. Reflection and Type Assertions

Reflection allows you to perform type assertions dynamically.

Example: Type Assertions Using Reflection

package main

import (
    "fmt"
    "reflect"
)

func printTypeAndAssert(i interface{}) {
    v := reflect.ValueOf(i)

    if v.Kind() == reflect.Int {
        fmt.Println("The value is an int:", v.Int())
    } else if v.Kind() == reflect.String {
        fmt.Println("The value is a string:", v.String())
    } else {
        fmt.Println("Unknown type")
    }
}

func main() {
    var x int = 42
    var y string = "hello"

    printTypeAndAssert(x)
    printTypeAndAssert(y)
}

Output: 

The value is an int: 42
The value is a string: hello

  • Kind(): Returns the kind of a value (e.g., reflect.Int, reflect.String).
  • Int() and String(): Return the underlying value of the respective type.

7. Limitations and Caution with Reflection

  1. Performance Overhead: Reflection adds runtime overhead due to type inspection and value manipulation. Avoid excessive use in performance-critical applications.

  2. Reduced Type Safety: Reflection bypasses Go's strong type checking, which can introduce bugs or unexpected behaviors if not handled carefully.

  3. Complexity: Reflection can make code harder to understand and maintain due to the dynamic nature of type handling.

8. Use Cases for Reflection

Reflection is used in Go in various scenarios where the type of an object cannot be known until runtime:

  • Serialization (e.g., JSON encoding/decoding): Libraries like encoding/json use reflection to handle different struct types dynamically.
  • Testing: Reflection allows for dynamic test case generation and introspection of test results.
  • ORMs: Reflection is used by Object-Relational Mappers to automatically map struct fields to database columns.
  • Dependency Injection and Mocking: Reflection is useful in scenarios where the dependency graph of objects must be dynamically created.

Conclusion

Reflection is a powerful tool in Go, but it should be used judiciously. It allows you to work with unknown types at runtime, but it introduces runtime overhead and reduces type safety. For most use cases, Go’s strong type system should be preferred, and reflection should only be used when absolutely necessary.