Reflection

Reflection in Go allows your program to inspect and manipulate variables, fields, methods, and types at runtime. It is a powerful feature provided by the reflect package in the standard library. However, reflection can be more complex than regular Go code and should be used judiciously. This in-depth overview with examples will guide you through the fundamentals and common use cases of reflection in Go.

Key Concepts of Reflection in Go

reflect.Type and reflect.Value
- reflect.Type provides information about the type of a variable (e.g., whether it’s a struct, slice, pointer, etc.).
- reflect.Value holds the runtime data itself and allows you to inspect or modify it (when possible).
TypeOf and ValueOf
- reflect.TypeOf(x) returns a reflect.Type describing the type of x.
- reflect.ValueOf(x) returns a reflect.Value holding the value of x.
Kinds vs. Concrete Types
- Kind (reflect.Kind) categorizes the underlying type (e.g., Int, String, Struct, Slice, Ptr, etc.).
- Concrete Type (reflect.Type) is the actual declared type (int, string, MyStruct, etc.).
Addressability
- A reflect.Value is only settable if it refers to an addressable (pointer) value.
- For example, you cannot modify a non-pointer struct’s fields through reflection unless you obtained its addressable reflect.Value.
Zero Values
- Reflection allows you to create zero values of a type or set a field to zero using reflect.New and related functions.

. Basic Reflection Usage

Example: Inspecting Types and Values

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x int = 42
    v := reflect.ValueOf(x)
    t := reflect.TypeOf(x)

    fmt.Printf("Value: %v, Type: %v\n", v, t)
    fmt.Printf("Kind: %v\n", v.Kind())
}

Explanation 1

ValueOf(x) gives a reflect.Value representing 42.
TypeOf(x) gives a reflect.Type representing int.
v.Kind() returns reflect.Int, indicating the kind of the underlying type.

Sample Output:

Value: 42, Type: int
Kind: int

2. Inspecting Struct Fields

Reflection is often used to inspect the fields and tags of a struct at runtime.

Example: Reading Struct Tags and Field Types

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

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

    v := reflect.ValueOf(p)
    t := reflect.TypeOf(p)

    for i := 0; i < v.NumField(); i++ {
        fieldValue := v.Field(i)
        fieldType := t.Field(i)

        fmt.Printf("Field Name: %s\n", fieldType.Name)
        fmt.Printf("Field Type: %s\n", fieldValue.Type())
        fmt.Printf("Field Value: %v\n", fieldValue.Interface())

        // Struct tags
        tag := fieldType.Tag.Get("json")
        fmt.Printf("JSON Tag: %s\n\n", tag)
    }
}

Explanation 2

reflect.TypeOf(p).Field(i) returns information about the struct field, including its name and tag.
reflect.ValueOf(p).Field(i) returns the value of that field.
NumField() tells how many fields a struct has.
Tag.Get("json") fetches the json struct tag.

Sample Output:

Field Name: Name
Field Type: string
Field Value: Alice
JSON Tag: name

Field Name: Age
Field Type: int
Field Value: 30
JSON Tag: age

3. Modifying Values with Reflection

Reflection can also modify values, but only if you have a pointer to an addressable value.

Example: Setting Struct Fields via Pointer

package main

import (
    "fmt"
    "reflect"
)

type Config struct {
    Host string
    Port int
}

func main() {
    c := Config{Host: "localhost", Port: 8080}

    // Get addressable Value
    v := reflect.ValueOf(&c).Elem()

    // Modify the Host field
    hostField := v.FieldByName("Host")
    if hostField.CanSet() && hostField.Kind() == reflect.String {
        hostField.SetString("127.0.0.1")
    }

    // Modify the Port field
    portField := v.FieldByName("Port")
    if portField.CanSet() && portField.Kind() == reflect.Int {
        portField.SetInt(9090)
    }

    fmt.Printf("Updated Config: %+v\n", c)
}

Explanation 3

We pass &c to reflect.ValueOf, then call .Elem() to get the struct value (addressable).
FieldByName("Host") and FieldByName("Port") retrieve fields by their names.
We check CanSet() to ensure the field can be modified.
We use SetString() and SetInt() to update the fields.

Sample Output:

Updated Config: &{Host:127.0.0.1 Port:9090}

4. Reflection on Slices and Maps

Example: Working with a Slice

package main

import (
    "fmt"
    "reflect"
)

func main() {
    numbers := []int{10, 20, 30}

    v := reflect.ValueOf(numbers)
    fmt.Println("Slice Kind:", v.Kind())

    // Modify an element
    elem := v.Index(1)
    if elem.CanSet() {
        elem.SetInt(99)
    }

    // Append a new element
    newValue := reflect.ValueOf(40)
    v = reflect.Append(v, newValue)

    // Convert back to interface
    updatedSlice := v.Interface().([]int)
    fmt.Println("Updated Slice:", updatedSlice)
}

Explanation 4

v.Index(1) gets the second element of the slice.
SetInt(99) modifies it if it’s addressable (in this case, it is not because the slice isn’t a pointer; see note below).
reflect.Append(v, newValue) appends a value to the slice; returns a new reflect.Value.

Sample Output:

Slice Kind: slice
Updated Slice: [10 20 30 40]

(But notice that the element at index 1 might not change to 99 unless we pass a pointer to the slice.)

5. Dynamic Function Calls

You can also use reflection to call methods dynamically.

Example: Invoking a Method by Name

package main

import (
    "fmt"
    "reflect"
)

type Calculator struct{}

func (Calculator) Add(a, b int) int {
    return a + b
}

func main() {
    calc := Calculator{}
    calcValue := reflect.ValueOf(calc)

    // Retrieve method by name
    addMethod := calcValue.MethodByName("Add")
    if !addMethod.IsValid() {
        fmt.Println("Method not found")
        return
    }

    // Prepare arguments
    args := []reflect.Value{
        reflect.ValueOf(10),
        reflect.ValueOf(5),
    }

    // Call the method
    results := addMethod.Call(args)

    // Extract the result
    sum := results[0].Interface().(int)
    fmt.Println("Sum:", sum)
}

Explanation 5

MethodByName("Add") returns a reflect.Value representing the Add method.
Call() executes the method with []reflect.Value as arguments.
We retrieve the result from the returned []reflect.Value.

Sample Output:

Sum: 15

6. Checking for Nil and Validity

Reflection can help you detect whether an interface or pointer is nil, or if a reflect.Value is valid.

Example: Detecting Nil and Zero Values

package main

import (
    "fmt"
    "reflect"
)

func checkNil(value interface{}) {
    v := reflect.ValueOf(value)
    if !v.IsValid() {
        fmt.Println("Invalid (nil) value")
        return
    }

    // Check if it's nil
    if v.Kind() == reflect.Ptr && v.IsNil() {
        fmt.Println("Value is nil pointer")
        return
    }

    fmt.Println("Value is not nil")
}

func main() {
    var ptr *int
    checkNil(ptr)

    var num int = 42
    checkNil(num)

    // Also works with empty interface
    checkNil(nil)
}

Explanation 6

v.IsValid() checks if the reflect.Value is valid (non-nil).
v.IsNil() checks if the underlying pointer or interface is nil (only valid for certain kinds like ptr, map, chan, func, interface).

Sample Output:

Value is nil pointer
Value is not nil
Invalid (nil) value

Best Practices and Caveats

Use Reflection Sparingly
- Reflection can make code harder to maintain and debug.
- Prefer normal interfaces and type assertions where possible.
Performance Overhead
- Reflection is slower than direct type operations.
- Use it only when truly necessary.
Maintain Clear Error Checking
- Reflection calls can fail if fields do not exist or are unexported.
Exported Fields
- Reflection can only set exported (capitalized) fields of structs. Unexported fields are not addressable or settable.
Avoid Overuse for Simple Tasks
- In many cases, simple function arguments or type switches are more readable than reflection-based solutions.

Summary

Reflection in Go is a powerful mechanism that allows runtime inspection and manipulation of types, values, and methods. By leveraging reflect.Value and reflect.Type, you can:

Dynamically inspect struct fields and tags.
Modify values if they are addressable.
Invoke methods by name.
Determine kinds (struct, slice, map, ptr, etc.) and handle them accordingly.

However, reflection should be used with care to keep your codebase readable and maintainable. Understanding the nuances of addressability, exported fields, and performance trade-offs is essential when working with reflection in Go.

Last modified: 01 January 2025