Go语言核心知识回顾(反射)

有时要求写一个函数有能力统一处理各种值类型的函数，而这些类型可能无法共享同一个接口，也可能布局未知，也有可能这个类型在设计函数时并不存在，当我们无法透视一个未知类型的布局时，这段代码就无法继续，这是就需要反射

reflect.Type & reflect.Value

反射功能由reflect包提供，其中定义了两个重要类型: Type 和 Value，Type表示Go语言的一个类型，它是一个有很多方法的接口，这些方法可以用来识别类型以及透视类型的组成部分，比如一个结构的各个字段或者一个函数的各个参数

reflect.Type接口只有一个实现，即类型描述符，接口值中的动态类型也是类型描述符号

t := reflect.TypeOf(3)

fmt.Println(t.String()) // int

fmt.Println(t) // int

reflect.TypeOf函数接收任何的interface{}参数，并且将接口中的动态类型以reflect.Type形式返回，将一个具体值赋给一个接口类型时会发生一个隐式类型转换，转换会生成一个包含两部分内容的接口值: 动态类型部分是操作数类型(int)，动态值部分是操作数值(3)，并且TypeOf返回一个接口值对应的动态类型，返回总是具体类型

var w io.Writer = os.Stdout

fmt.Println(reflect.TypeOf(w)) // *os.File

上述代码输出的是*os.File而不是io.Writer

reflect.Value可以包含一个任意类型的值，reflect.ValueOf函数接收任意的interface{}并将接口的动态值以reflect.Value的形式返回，返回值同样是具体值，不过包含一个接口值

v := reflect.ValueOf(3)

fmt.Println(v) // 3

fmt.Printf("%v\n", v) // 3

fmt.Println(v.String()) // <int value>

调用Value的Type方法会将其类型以reflect.Type方式返回

v := reflect.ValueOf(3)

t := v.Type()

fmt.Println(t.String()) // int

reflect.Value的逆操作是reflect.Value.Interface方法，返回一个interface{}接口值，与reflect.Value包含一个具体值

v := reflect.ValueOf(3)

x := v.Interface()

i := x.(int)

fmt.Printf("%d\n", i)

reflect.Value和interface{}都可以任意的值，二者的区别是空接口(interface{})，隐藏了值的布局信息、内置操作和相关方法，所以除非知道其动态类型，并用一个类型断言来渗透进去，否则对所包含值能做的事情很少，Value有很多方法可以用来分析所包含的值，而不用知道它的类型，基于此可以尝试写一个通用的格式化函数:

package format

import (

	"reflect"

	"strconv"

)

func Any(value interface{}) string {

	return formatAtom(reflect.ValueOf(value))

}

func formatAtom(v reflect.Value) string {

	switch v.Kind() {

	case reflect.Invalid:

		return "invalid"

	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

		return strconv.FormatInt(v.Int(), 8)

	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:

		return strconv.FormatUint(v.Uint(), 10)

	case reflect.Bool:

		return strconv.FormatBool(v.Bool())

	case reflect.String:

		return strconv.Quote(v.String())

	case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Slice, reflect.Map:

		return v.Type().String() + "0x" + strconv.FormatUint(uint64(v.Pointer()), 16)

	default:

		return v.Type().String() + " value"

	}

}

调用:

func main() {

	var x int64 = 1

	var d time.Duration = 1 * time.Nanosecond

	fmt.Println(format.Any(x))

	fmt.Println(format.Any(d))

	fmt.Println(format.Any([]int64{x}))

	fmt.Println(format.Any([]time.Duration{d}))

}

输出:

1

1

[]int640xc0000200f8

[]time.Duration0xc000020110

值显示

实现一个函数Display，对于给定的任意一个复杂值x，输出这个复杂值的完整结构，并对找到的每个元素标上这个元素的路径

func Display(name string, x interface{}) {

	fmt.Printf("Display %s (%T):\n", name, x)

	display(name, reflect.ValueOf(x))

}

func display(path string, v reflect.Value) {

	switch v.Kind() {

	case reflect.Invalid:

		fmt.Printf("%s = invalid\n", path)

	case reflect.Slice, reflect.Array:

		for i := 0; i < v.Len(); i++ {

			display(fmt.Sprintf("%s[%d]", path, i), v.Index(i))

		}

	case reflect.Struct:

		for i := 0; i < v.NumField(); i++ {

			fieldPath := fmt.Sprintf("%s %s", path, v.Type().Field(i).Name)

			display(fieldPath, v.Field(i))

		}

	case reflect.Map:

		for _, key := range v.MapKeys() {

			display(fmt.Sprintf("%s[%s]", path, formatAtom(key)), v.MapIndex(key))

		}

	case reflect.Ptr:

		if v.IsNil() {

			fmt.Printf("%s = nil\n", path)

		} else {

			display(fmt.Sprintf("(*%s)", path), v.Elem())

		}

	case reflect.Interface:

		if v.IsNil() {

			fmt.Printf("%s = nil\n", path)

		} else {

			fmt.Printf("%s.type = %s\n", path, v.Elem().Type())

			display(path+".value", v.Elem())

		}

	default:

		fmt.Printf("%s = %s\n", path, formatAtom(v))

	}

}

在上述display函数中，我们使用之前定义的formatAtom函数来输出基础值(基础类型、函数和通道)，使用reflect.Value的一些方法来递归展示复杂类型的每个组成部分，当递归深入时，path字符串会增长，以表示如何找到当前值

其中Len方法会返回slice或者数组中元素个数，NumField可以报告结果中的字段数，Field(i)会返回第i个字段，返回字段类型为reflect.Value，MapKeys方法返回一个元素类型为reflect.Value的slice， 每个元素都是一个map的键，Elem方法返回指针指向的变量，这个方法在指针是nil时也能正确处理，返回的结果属于Invalid类型，所以用IsNil来显式检测

测试:

func main() {

	strangelove := Movie{

		Title:    "Dr.Strangelove",

		Subtitle: "How I learned to Stop Worring and Love the Bomb",

		Year:     1964,

		Color:    false,

		Actor: map[string]string{

			"Dr.Strangelove":            "Peter Sellers",

			"Grp.Capt. Lionel Mandrake": "Peter Sellers",

			"Gen. Buck Turgidson":       "George C.Scott",

		},

		Oscars: []string{

			"Best Actor (Nomin.)",

			"Best Adapted Screenplay (Nomin.)",

		},

	}

	format.Display("strangelove", strangelove)

}

输出:

Display strangelove (main.Movie):

strangelove Title = "Dr.Strangelove"

strangelove Subtitle = "How I learned to Stop Worring and Love the Bomb"

strangelove Year = 3654

strangelove Color = false

strangelove Actor["Dr.Strangelove"] = "Peter Sellers"

strangelove Actor["Grp.Capt. Lionel Mandrake"] = "Peter Sellers"

strangelove Actor["Gen. Buck Turgidson"] = "George C.Scott"

strangelove Oscars[0] = "Best Actor (Nomin.)"

strangelove Oscars[1] = "Best Adapted Screenplay (Nomin.)"

strangelove Sequel = nil

设置值

一个变量是一个可寻址的存储区域，其中包含了一个值，并且其值可以通过这个地址进行更新

x := 2

a := reflect.ValueOf(2)

b := reflect.ValueOf(x)

c := reflect.ValueOf(&x)

d := c.Elem()

reflect.ValueOf返回的reflect.Value都是不可寻址的，但d是通过c的指针得来的，所以是可寻址的，通过如下方法来询问是否可寻址

fmt.Println(a.CanAddr(), b.CanAddr(), c.CanAddr(), d.CanAddr()) // false false false true

可直接通过reflect.Value来更新变量，无须通过指针，而是reflect.Set方法

x := 2

d := reflect.ValueOf(&x).Elem()

px := d.Addr().Interface().(*int)

*px = 3

fmt.Println(x) // 3

d.Set(reflect.ValueOf(4))

fmt.Println(x) // 4

Go语言核心知识回顾(反射)的相关教程结束。