反射

反射是用程序检查代码中所拥有的结构尤其是类型的一种能力，这是元编程的一种形式。反射可以在运行时检查类型和变量。但是存在着一定的隐患，除非真的有必要，否则应当避免使用或者小心使用。

方法和类型的反射

两个简单的函数：reflect.TypeOf和reflect.ValueOf，返回被检查对象的类型和值。
两个函数的签名：

func TypeOf(i interface{}) Type
func ValueOf(i interface{}) Value

其中，Type和Value都有Kind方法返回一个常量来表示类型：Uint,Float64,Slice等，同样Value有叫作Int,Float的方法可以获取存储在内部的值。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    fmt.Println("type:", reflect.TypeOf(x))
    v := reflect.ValueOf(x)
    fmt.Println("value: ", v)
    fmt.Println("type: ", v.Type())
    fmt.Println("kind: ", v.Kind())
    fmt.Println("value: ", v.Float())
    fmt.Println(v.Interface())
    fmt.Printf("value is %5.2e\n", v.Interface())
    y := v.Interface().(float64)
    fmt.Println(y)
}

/** The result is:
type: float64
value:  3.4
type:  float64
kind:  float64
value:  3.4
3.4
value is 3.40e+00
3.4
 */

从上述代码中可以很好的看出每一个函数的功能。

通过反射修改设置值

Value中是有方法可以对x的值进行修改的，但是一定要谨慎使用v.SetFloat(3.1415)函数，因为可能会产生错误：

/** reflect.Value.SetFloat using unaddressable value */

其实我们是可以通过v.CanSet()来进行测试的，测试是否可以设置。如果想要解决上述问题，我们需要间接使用v=v.Elem()才能实现我们想要的效果

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var x float64 = 3.4
    v := reflect.ValueOf(x)
    fmt.Println("v: ", v.CanSet())
    v = reflect.ValueOf(&x)
    fmt.Println("v的类型: ", v.Type())
    fmt.Println("v: ", v.CanSet())
    v = v.Elem()
    fmt.Println("v的Elem是: ", v)
    fmt.Println("v: ", v.CanSet())
    v.SetFloat(3.1415)
    fmt.Println(v.Interface())
    fmt.Println(v)
}

/** The result is:
v:  false
v的类型:  *float64
v:  false
v的Elem是:  3.4
v:  true
3.1415
3.1415
 */

反射结构

有些时候需要反射一个结构类型：NumField()方法返回结构内的字段数量，通过一个for循环索引取得每个字段的值Field(i)。

package main

import (
    "fmt"
    "reflect"
)

type NotknownType struct {
    s1, s2, s3 string
}

func (n NotknownType) String() string {
    return n.s1 + "-" + n.s2 + "-" + n.s3
}

var secret interface{} = NotknownType{"Google", "Go", "Code"}

func main() {
    value := reflect.ValueOf(secret)
    typ := reflect.TypeOf(secret)
    fmt.Println(typ)
    knd := value.Kind()
    fmt.Println(knd)

    for i := 0; i < value.NumField(); i++ {
        // 返回结构体的第i个字段（的Value封装）。如果v的Kind不是Struct或i出界会panic
        fmt.Printf("Field %d: %v\n", i, value.Field(i))
    }


    // 返回v持有值类型的第i个方法的已绑定（到v的持有值的）状态的函数形式的Value封装。
    // 返回值调用Call方法时不应包含接收者；返回值持有的函数总是使用v的持有者作为接收者（即第一个参数）。
    // 如果i出界，或者v的持有值是接口类型的零值（nil），会panic。
    results := value.Method(0).Call(nil)
    fmt.Println(results)
}

/** The result is:
main.NotknownType
struct
Field 0: Google
Field 1: Go
Field 2: Code
[Google-Go-Code]
 */

同样，在尝试修改一个值的时候，会产生错误：

panic:reflect.Value.SetString using value obtained using unexported field

这是因为结构中只有被导出字段（首字母大写）才是可设置的

Printf和反射

fmt包中的Printf函数是使用反射机制来分析它的...参数的，Printf函数声明：

func Printf(format string, args ...interface{}) (n int, err error)

下面实现一个简单的通用输出函数，其中使用了type-switch来推导参数类型，并根据类型来输出每个参数的值：

package main

import (
    "os"
    "strconv"
)

type Stringer interface {
    String() string
}

type Celsius float64

func (c Celsius) String() string {
    return strconv.FormatFloat(float64(c), 'f', 1, 64) + "C"
    /**
        func FormatFloat(f float64, fmt byte, prec, bitSize int) string
        函数将浮点数表示为字符串并返回。
        bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。
        fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。
        prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。
     */
}

type Day int

var dayName = []string{"Monday", "Tudesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}

func (day Day) String() string {
    return dayName[day]
}

func printf(args ...interface{}) {
    for i, arg := range args {
        if i > 0 {os.Stdout.WriteString(" ")}
        switch a := arg.(type) { // 类型转换
        case Stringer: os.Stdout.WriteString(a.String())
        case int:      os.Stdout.WriteString(strconv.Itoa(a))
        case string:   os.Stdout.WriteString(a)
        // more type
        default:       os.Stdout.WriteString("???")
        }
    }
}

func main() {
    print(Day(1), "温度是", Celsius(18.36))
}