Go语言反射深入讲解

反射基础概念

什么是反射？ 反射是一种在运行时检查和操作类型的机制。它允许程序动态地获取类型信息，并对对象进行操作。

基本类型 反射的基本类型包括：

• reflect.Type：表示类型信息。
• reflect.Value：表示值信息。

获取类型信息

使用 reflect.TypeOf

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a int = 10
    t := reflect.TypeOf(a)
    fmt.Println(t) // 输出：int
}

使用 reflect.ValueOf

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a int = 10
    v := reflect.ValueOf(a)
    fmt.Println(v) // 输出：10
}

类型转换

使用 Interface 方法

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a int = 10
    v := reflect.ValueOf(a)
    b := v.Interface().(int)
    fmt.Println(b) // 输出：10
}

使用 Convert 方法

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a int = 10
    v := reflect.ValueOf(a)
    b := v.Convert(reflect.TypeOf(float64(0))).Interface().(float64)
    fmt.Println(b) // 输出：10
}

检查类型

使用 Kind 方法

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a int = 10
    t := reflect.TypeOf(a)
    fmt.Println(t.Kind()) // 输出：int
}

使用 Type 方法

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{"Alice", 25}
    t := reflect.TypeOf(p)
    fmt.Println(t) // 输出：main.Person
}

操作结构体

获取结构体字段

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{"Alice", 25}
    v := reflect.ValueOf(p)
    t := v.Type()

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

修改结构体字段

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{"Alice", 25}
    v := reflect.ValueOf(&p).Elem()
    t := v.Type()

    for i := 0; i < v.NumField(); i++ {
        field := t.Field(i)
        value := v.Field(i)
        switch field.Name {
        case "Name":
            value.SetString("Bob")
        case "Age":
            value.SetInt(30)
        }
    }

    fmt.Println(p) // 输出：{Bob 30}
}

操作数组和切片

获取数组和切片长度

package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := []int{1, 2, 3, 4, 5}
    v := reflect.ValueOf(a)
    fmt.Println(v.Len()) // 输出：5
}

遍历数组和切片

package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := []int{1, 2, 3, 4, 5}
    v := reflect.ValueOf(a)

    for i := 0; i < v.Len(); i++ {
        fmt.Println(v.Index(i).Interface())
    }
}

操作映射表

获取映射表键值

package main

import (
    "fmt"
    "reflect"
)

func main() {
    m := map[string]int{"a": 1, "b": 2, "c": 3}
    v := reflect.ValueOf(m)

    for _, key := range v.MapKeys() {
        value := v.MapIndex(key)
        fmt.Printf("%v: %v\n", key.Interface(), value.Interface())
    }
}

修改映射表

package main

import (
    "fmt"
    "reflect"
)

func main() {
    m := map[string]int{"a": 1, "b": 2, "c": 3}
    v := reflect.ValueOf(&m).Elem()

    v.SetMapIndex(reflect.ValueOf("d"), reflect.ValueOf(4))

    fmt.Println(m) // 输出：map[a:1 b:2 c:3 d:4]
}

操作接口

获取接口值

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var i interface{} = "Hello, World!"
    v := reflect.ValueOf(i)
    fmt.Println(v.Interface()) // 输出：Hello, World!
}

修改接口值

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var i interface{} = "Hello, World!"
    v := reflect.ValueOf(&i).Elem()
    v.Set(reflect.ValueOf("Goodbye, World!"))

    fmt.Println(i) // 输出：Goodbye, World!
}

操作函数

调用函数

package main

import (
    "fmt"
    "reflect"
)

func add(a, b int) int {
    return a + b
}

func main() {
    args := []reflect.Value{reflect.ValueOf(1), reflect.ValueOf(2)}
    result := reflect.ValueOf(add).Call(args)[0].Interface().(int)
    fmt.Println(result) // 输出：3
}

调用方法

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func (p *Person) SayHello() string {
    return fmt.Sprintf("%s says hello!", p.Name)
}

func main() {
    p := &Person{"Alice", 25}
    method := reflect.ValueOf(p).MethodByName("SayHello")
    result := method.Call(nil)[0].Interface().(string)
    fmt.Println(result) // 输出：Alice says hello!
}

反射与类型断言

类型断言

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var i interface{} = "Hello, World!"
    if str, ok := i.(string); ok {
        fmt.Println(str) // 输出：Hello, World!
    } else {
        fmt.Println("Not a string")
    }
}

使用反射进行类型断言

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var i interface{} = "Hello, World!"
    v := reflect.ValueOf(i)
    if v.Kind() == reflect.String {
        fmt.Println(v.Interface()) // 输出：Hello, World!
    } else {
        fmt.Println("Not a string")
    }
}

反射与类型转换

类型转换

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var i interface{} = 10
    v := reflect.ValueOf(i)
    f := v.Convert(reflect.TypeOf(float64(0))).Interface().(float64)
    fmt.Println(f) // 输出：10
}

复杂类型的转换

package main

import (
    "fmt"
    "reflect"
)

type Point struct {
    X float64
    Y float64
}

func main() {
    var p interface{} = Point{X: 1.0, Y: 2.0}
    v := reflect.ValueOf(p)
    newPoint := v.Convert(reflect.TypeOf(Point{})).Interface().(Point)
    fmt.Println(newPoint) // 输出：{1 2}
}