时间和反射

time标准库

时间类型 time.Time

now := time.Now()
fmt.Println(now)
fmt.Println(now.Year())
fmt.Println(now.Month())
fmt.Println(now.Day())
fmt.Println(now.Date())
fmt.Println(now.Hour())
fmt.Println(now.Minute())
fmt.Println(now.Second())

时间戳

// 时间戳
fmt.Println(now.Uinx())
fmt.Println(now.UinxNano())

// timr.Unix 把时间戳转换成时间
ret := time.Unix(1564803667, 0)
fmt.Println(ret)
fmt.Println(ret.Year())
fmt.Println(ret.Day())

时间间隔

// 时间间隔
fmt.Println(time.Second)
// now + 24 小时
fmt.Println(now.Add(24*time.Hour))

定时器

timer := time.Tick(time.Second)
for t:= range timer{
    fmt.Println(t)  // 1秒执行一次
}

格式化时间

// 格式化时间，把时间对象转换成字符串类型的时间
// 2021-09-16
fmt.Println(now.Format("2006-01-02"))
// 2021/09/16 11:55:02
fmt.Println(now.Format("2006/01/02 15:04:05"))
// 2021/09/16 11:55:02 AM
fmt.Println(now.Format("2006/01/02 03:04:05 PM"))
// // 2021/09/16 11:55:02.342
fmt.Println(now.Format("2006/01/02 15:04:05.000"))
// 按照对应的格式解析字符串类型的时间
timeObj,err :=  time.Parse("2006-01-02"."2021-09-16")
if err != nil {
    fmt.Println(err))
    return
}
fmt.Println(timeObj)
fmt.Println(timeObj.Unix())

反射

反射的应用

json反序列化就是反射的应用
{"name":"mingzi","age":10}

type person struct{
    Name string ``
}

反射的两个方法

reflect.TypeOf 和reflect。ValueOf
type 又分为Name(),Kind()

package main

import (
	"fmt"
	"reflect"
)

type Cat struct {
}

func reflectType(x interface{}) {
	v := reflect.TypeOf(x)
	fmt.Printf("type:%v
", v)
	fmt.Printf("type name:%v type kind:%v
", v.Name(), v.Kind())
}

func reflectValue(x interface{}) {
	v := reflect.ValueOf(x)
	k := v.Kind() // 值的类型种类
	switch k {
	case reflect.Int64:
		// v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换
		fmt.Printf("type is int64, value is %d
", int64(v.Int()))
	case reflect.Float32:
		// v.Float()从反射中获取整型的原始值，然后通过float32()强制类型转换
		fmt.Printf("type is float32, value is %f
", float32(v.Float()))
	case reflect.Float64:
		// v.Float()从反射中获取整型的原始值，然后通过float64()强制类型转换
		fmt.Printf("type is float64, value is %f
", float64(v.Float()))
	}
}

// 通过反射设置变量的值
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)
	if v.Elem().Kind() == reflect.Int64 {
		v.Elem().SetInt(200) //修改的是副本，reflect包会引发panic
	}
}

func main() {
	var a float32 = 3.14
	reflectType(a) // type:float32
	var b int64 = 100
	reflectType(b) // type:int64
	var c = Cat{}
	reflectType(c)
	// ValueOf
	reflectValue(a)
	// 设置值
	// reflectSetValue1(&b)
	reflectSetValue2(&b)
	fmt.Println(b)
}

结构体反射

type student struct {
    Name string `json:"name" xiaowang:"haha"`
    Score string `json:"age" xiaohong :"hehe"`
}

func main(){
    stu1 := student{
        "小王"
        "100"
    }
    t := reflect.TypeOf(stu1)
    fmt.Println(t.Name(),t.Kind())  // student struct
    // 通过for循环遍历结构体的所有字段信息
    fmt.Println(t.NumField()) // 2
    for i:=0 ; i< t.NumFied();i++{
        field := t.Field(i)
		fmt.Printf("name:%s index:%d type:%v json tag:%v
", field.Name, field.Index, field.Type, field.Tag.Get("xiaowang"))
    }
    // 通过字段名获取指定结构体字段信息
	if scoreField, ok := t.FieldByName("Score"); ok {
		fmt.Printf("name:%s index:%d type:%v json tag:%v
", scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"))
	}
}