反射

go

Go语言中的变量是分为两部分的:

  • 类型信息：预先定义好的元信息。
  • 值信息：程序运行过程中可动态变化的。

反射介绍

反射是指在程序运行期间对程序本身进行访问和修改的能力。程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。

支持反射的语言可以在程序编译期间将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期间获取类型的反射信息，并且有能力修改它们。

Go程序在运行期间使用reflect包访问程序的反射信息。

在上一篇博客中我们介绍了空接口。 空接口可以存储任意类型的变量，那我们如何知道这个空接口保存的数据是什么呢？ 反射就是在运行时动态的获取一个变量的类型信息和值信息

reflect包

在Go语言的反射机制中，任何接口值都由是一个具体类型和具体类型的值两部分组成的(我们在上一篇接口的博客中有介绍相关概念)。 在Go语言中反射的相关功能由内置的reflect包提供，任意接口值在反射中都可以理解为由reflect.Type和reflect.Value两部分组成，并且reflect包提供了reflect.TypeOf和reflect.ValueOf两个函数来获取任意对象的Value和Type。

TypeOf

func reflectType(x interface{}) {
	v := reflect.TypeOf(x)
	fmt.Printf("type:%v\n", v)
}
func main() {
	var a float32 = 3.14
	reflectType(a) // type:float32
	var b int64 = 100
	reflectType(b) // type:int64
}
type name和type kind

在反射中关于类型还划分为两种：类型（Type）和种类（Kind）。因为在Go语言中我们可以使用type关键字构造很多自定义类型，而种类（Kind）就是指底层的类型，但在反射中，当需要区分指针、结构体等大品种的类型时，就会用到种类（Kind）。 举个例子，我们定义了两个指针类型和两个结构体类型，通过反射查看它们的类型和种类。

var a *float32 // 指针
var b myInt    // 自定义类型
var c rune     // 类型别名
reflectType(a) // type: kind:ptr
reflectType(b) // type:myInt kind:int64
reflectType(c) // type:int32 kind:int32

type person struct {
	name string
	age  int
}
type book struct{ title string }
var d = person{
	name: "沙河小王子",
	age:  18,
}
var e = book{title: "《跟小王子学Go语言》"}
reflectType(d) // type:person kind:struct
reflectType(e) // type:book kind:struct

Go语言的反射中像数组、切片、Map、指针等类型的变量，它们的.Name()都是返回空。

在reflect包中定义的Kind类型如下：

type Kind uint
const (
    Invalid Kind = iota  // 非法类型
    Bool                 // 布尔型
    Int                  // 有符号整型
    Int8                 // 有符号8位整型
    Int16                // 有符号16位整型
    Int32                // 有符号32位整型
    Int64                // 有符号64位整型
    Uint                 // 无符号整型
    Uint8                // 无符号8位整型
    Uint16               // 无符号16位整型
    Uint32               // 无符号32位整型
    Uint64               // 无符号64位整型
    Uintptr              // 指针
    Float32              // 单精度浮点数
    Float64              // 双精度浮点数
    Complex64            // 64位复数类型
    Complex128           // 128位复数类型
    Array                // 数组
    Chan                 // 通道
    Func                 // 函数
    Interface            // 接口
    Map                  // 映射
    Ptr                  // 指针
    Slice                // 切片
    String               // 字符串
    Struct               // 结构体
    UnsafePointer        // 底层指针
)

ValueOf

reflect.ValueOf()返回的是reflect.Value类型，其中包含了原始值的值信息。reflect.Value与原始值之间可以互相转换。

方法 说明
Interface() interface {} 将值以 interface{} 类型返回，可以通过类型断言转换为指定类型
Int() int64 将值以 int 类型返回，所有有符号整型均可以此方式返回
Uint() uint64 将值以 uint 类型返回，所有无符号整型均可以此方式返回
Float() float64 将值以双精度（float64）类型返回，所有浮点数（float32、float64）均可以此方式返回
Bool() bool 将值以 bool 类型返回
Bytes() []bytes 将值以字节数组 []bytes 类型返回
String() string 将值以字符串类型返回 
v := reflect.ValueOf(x)

通过反射设置变量的值

想要在函数中通过反射修改变量的值，需要注意函数参数传递的是值拷贝，必须传递变量地址才能修改变量值。而反射中使用专有的Elem()方法来获取指针对应的值

package main

import (
	"fmt"
	"reflect"
)

func reflectSetValue1(x interface{}) {
	v := reflect.ValueOf(x)
	if v.Kind() == reflect.Int64 {
		v.SetInt(200) //修改的是副本，reflect包会引发panic
	}
}
func reflectSetValue2(x interface{}) {
	v := reflect.ValueOf(x)
	// 反射中使用 Elem()方法获取指针对应的值
	if v.Elem().Kind() == reflect.Int64 {
		v.Elem().SetInt(200)
	}
}
func main() {
	var a int64 = 100
	// reflectSetValue1(a) //panic: reflect: reflect.Value.SetInt using unaddressable value
	reflectSetValue2(&a)
	fmt.Println(a)
}

isNil()和isValid()

IsNil()报告v持有的值是否为nil。v持有的值的分类必须是通道、函数、接口、映射、指针、切片之一；否则IsNil函数会导致panic。

IsValid()返回v是否持有一个值。如果v是Value零值会返回假，此时v除了IsValid、String、Kind之外的方法都会导致panic。

IsNil()常被用于判断指针是否为空；IsValid()常被用于判定返回值是否有效。

// 尝试从结构体中查找"abc"字段
	fmt.Println("不存在的结构体成员:", reflect.ValueOf(b).FieldByName("abc").IsValid())
	// 尝试从结构体中查找"abc"方法
	fmt.Println("不存在的结构体方法:", reflect.ValueOf(b).MethodByName("abc").IsValid())
	// map
	c := map[string]int{}
	// 尝试从map中查找一个不存在的键
	fmt.Println("map中不存在的键：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("娜	   扎")).IsValid())

结构体反射

与结构体相关的方法

ield(i int) StructField 根据索引，返回索引对应的结构体字段的信息。
NumField() int 返回结构体成员字段数量。
FieldByName(name string) (StructField, bool) 根据给定字符串返回字符串对应的结构体字段的信息。
FieldByIndex(index []int) StructField 多层成员访问时，根据 []int 提供的每个结构体的字段索引，返回字段的信息。
FieldByNameFunc(match func(string) bool) (StructField,bool) 根据传入的匹配函数匹配需要的字段。
NumMethod() int 返回该类型的方法集中方法的数目
Method(int) Method 返回该类型方法集中的第i个方法
MethodByName(string)(Method, bool) 根据方法名返回该类型方法集中的方法 
for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fmt.Printf("name:%s index:%d type:%v json tag:%v\n", field.Name, field.Index, field.Type, field.Tag.Get("json"))
	}

反射是把双刃剑

反射是一个强大并富有表现力的工具，能让我们写出更灵活的代码。但是反射不应该被滥用，原因有以下三个。

  1. 基于反射的代码是极其脆弱的，反射中的类型错误会在真正运行的时候才会引发panic，那很可能是在代码写完的很长时间之后。
  2. 大量使用反射的代码通常难以理解。
  3. 反射的性能低下，基于反射实现的代码通常比正常代码运行速度慢一到两个数量级。

python反射

在 Python 中，我们可以使用反射机制来查看和修改对象的属性和方法，包括动态获取对象的属性和方法列表、获取和修改对象的属性值、动态调用对象的方法等。Python 中的反射机制主要通过内置函数 getattr()、setattr()、hasattr()、delattr() 和 vars() 等实现。

  • getattr() 函数可以用于获取对象的属性或方法，如果属性或方法不存在，会抛出 AttributeError 异常。
  • setattr() 函数可以用于设置对象的属性或方法，如果属性或方法不存在，会自动添加。
  • hasattr() 函数可以用于判断对象是否有指定的属性或方法，返回布尔值。
  • delattr() 函数可以用于删除对象的属性或方法。
  • vars() 函数可以返回对象的 __dict__ 属性，也就是对象的属性和值组成的字典。
  • type(object): 返回对象的类型。
  • isinstance(object, classinfo): 判断对象是否为指定类型或其子类的实例。
  • issubclass(class, classinfo): 判断一个类是否为另一个类的子类。
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def say_hello(self):
        print(f"Hello, my name is {self.name}. I'm {self.age} years old.")

person = Person("Alice", 25)

# 动态获取对象的属性列表
print(dir(person))

# 动态获取对象的属性值
print(getattr(person, "name"))
print(getattr(person, "age"))
print(getattr(person, "gender", "Unknown")) # 第三个参数为默认值，避免属性不存在时抛出异常

# 动态调用对象的方法
method_name = "say_hello"
if hasattr(person, method_name):
    method = getattr(person, method_name)
    method()

# 动态设置对象的属性
setattr(person, "age", 26)
print(person.age)

# 动态添加对象的属性
setattr(person, "gender", "Female")
print(person.gender)

# 删除对象的属性
delattr(person, "gender")
print(hasattr(person, "gender"))

c++ 反射

C++ 是一门静态语言，其并没有直接支持反射。C++ 可以通过元编程技术实现类似于反射的功能，比如使用模板元编程（TMP，Template Meta-Programming）技术。TMP 可以让程序在编译期间进行一些计算，从而达到运行期间反射的效果。

另外，C++11 开始支持了一种叫做 type_traits 的库，它提供了一些模板类型特性（Traits），可以在编译期间查询和操作类型的信息。通过这些模板类型特性，可以实现一些类似于反射的功能，比如查询类型是否具有某个成员函数、成员变量等信息。

虽然 C++ 并没有直接支持反射，但是通过 TMP 和 type_traits 库，可以实现类似于反射的功能。不过相比于动态语言，C++ 反射的实现较为复杂，需要更多的编码工作。

type_traits

type_traits 是 C++11 引入的一个头文件，它定义了一系列的类型特征（type traits），用于在编译时对类型进行分析和操作，从而更好地支持泛型编程。由于 C++ 是静态类型语言，编译器在编译阶段需要明确每个变量和函数的类型，因此使用 type_traits 可以在编译期间进行类型检查和操作，而不需要运行时判断，提高了代码的效率和可靠性。

它的作用有以下几个方面：

  1. 提供编译时对类型进行分析的功能，如判断一个类型是否为指针类型、是否为 const 类型等等。
  2. 提供一些转换类型的方法，如将一个类型转换为指针类型、将一个类型转换为 const 类型等等。
  3. 提供一些特定类型的方法，如获取一个类型的指针类型、获取一个类型的 const 类型等等。
  4. 支持模板元编程，即将模板作为参数，然后在编译时对模板进行处理，从而得到另一个模板。

下面是一些 type_traits 库中常用的类型特征：

  1. is_void：判断一个类型是否为 void。
  2. is_integral：判断一个类型是否为整数类型，包括有符号整数、无符号整数和布尔类型。
  3. is_floating_point：判断一个类型是否为浮点数类型。
  4. is_array：判断一个类型是否为数组类型。
  5. is_pointer：判断一个类型是否为指针类型。
  6. is_reference：判断一个类型是否为引用类型。
  7. is_const：判断一个类型是否为 const 类型。
  8. is_function：判断一个类型是否为函数类型。
  9. is_member_pointer：判断一个类型是否为成员指针类型。
#include <iostream>
#include <type_traits>

template<typename T>
void check_type()
{
    if(std::is_floating_point<T>::value)
        std::cout << "Type is float or double" << std::endl;
    else
        std::cout << "Type is not float or double" << std::endl;
}

int main()
{
    check_type<int>();   // Type is not float or double
    check_type<float>(); // Type is float or double
    check_type<double>();// Type is float or double

    return 0;
}

在这个例子中，std::is_floating_point 模板可以检查给定类型是否为浮点类型，如果是则返回 true，否则返回 false。在 check_type 函数中，我们可以使用 if 语句根据 std::is_floating_point 的返回值来判断类型是否为浮点类型。