1
now := time.Now()
2
fmt.Println(now)
3
fmt.Println(now.Year())
4
fmt.Println(now.Month())
5
fmt.Println(now.Day())
6
fmt.Println(now.Date())
7
fmt.Println(now.Hour())
8
fmt.Println(now.Minute())
9
fmt.Println(now.Second())

1
// 时间戳
2
fmt.Println(now.Unix())
3
fmt.Println(now.UnixNano())
4
// time.Unix()
5
ret := time.Unix(1564803667, 0)
6
fmt.Println(ret)
7
fmt.Println(ret.Year())
8
fmt.Println(ret.Day())

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

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

1
// 格式化时间 把语言中时间对象 转换成字符串类型的时间
2
// 2019-08-03
3
fmt.Println(now.Format("2006-01-02"))
4
// 2019/02/03 11:55:02
5
fmt.Println(now.Format("2006/01/02 15:04:05"))
6
// 2019/02/03 11:55:02 AM
7
fmt.Println(now.Format("2006/01/02 03:04:05 PM"))
8
// // 2019/02/03 11:55:02.342
9
fmt.Println(now.Format("2006/01/02 15:04:05.000"))
10
// 按照对应的格式解析字符串类型的时间
11
timeObj, err := time.Parse("2006-01-02", "2019-08-03")
12
if err != nil {
13
  fmt.Printf("parse time failed, err:%v\n", err)
14
  return
15
}
16
fmt.Println(timeObj)
17
fmt.Println(timeObj.Unix())

1
package main
2

3
import (
4
  "fmt"
5
  "reflect"
6
)
7

8
type Cat struct {
9
}
10

11
func reflectType(x interface{}) {
12
  v := reflect.TypeOf(x)
13
  fmt.Printf("type:%v\n", v)
14
  fmt.Printf("type name:%v type kind:%v\n", v.Name(), v.Kind())
15
}
16

17
func reflectValue(x interface{}) {
18
  v := reflect.ValueOf(x)
19
  k := v.Kind() // 值的类型种类
20
  switch k {
21
  case reflect.Int64:
22
    // v.Int()从反射中获取整型的原始值，然后通过int64()强制类型转换
23
    fmt.Printf("type is int64, value is %d\n", int64(v.Int()))
24
  case reflect.Float32:
25
    // v.Float()从反射中获取整型的原始值，然后通过float32()强制类型转换
26
    fmt.Printf("type is float32, value is %f\n", float32(v.Float()))
27
  case reflect.Float64:
28
    // v.Float()从反射中获取整型的原始值，然后通过float64()强制类型转换
29
    fmt.Printf("type is float64, value is %f\n", float64(v.Float()))
30
  }
31
}
32

33
// 通过反射设置变量的值
34
func reflectSetValue1(x interface{}) {
35
  v := reflect.ValueOf(x)
36
  if v.Kind() == reflect.Int64 {
37
    v.SetInt(200) //修改的是副本，reflect包会引发panic
38
  }
39
}
40

41
func reflectSetValue2(x interface{}) {
42
  v := reflect.ValueOf(x)
43
  if v.Elem().Kind() == reflect.Int64 {
44
    v.Elem().SetInt(200) //修改的是副本，reflect包会引发panic
45
  }
46
}
47

48
func main() {
49
  var a float32 = 3.14
50
  reflectType(a) // type:float32
51
  var b int64 = 100
52
  reflectType(b) // type:int64
53
  var c = Cat{}
54
  reflectType(c)
55
  // ValueOf
56
  reflectValue(a)
57
  // 设置值
58
  // reflectSetValue1(&b)
59
  reflectSetValue2(&b)
60
  fmt.Println(b)
61
}

1
package main
2

3
import (
4
  "fmt"
5
  "reflect"
6
)
7

8
type student struct {
9
  Name  string `json:"name" zhoulin:"嘿嘿嘿"`
10
  Score int    `json:"score" zhoulin:"哈哈哈"`
11
}
12

13
func main() {
14
  stu1 := student{
15
    Name:  "小王子",
16
    Score: 90,
17
  }
18

19
  t := reflect.TypeOf(stu1)
20

21
  fmt.Println(t.Name(), t.Kind()) // student struct
22

23
  // 通过for循环遍历结构体的所有字段信息
24
  fmt.Println(t.NumField()) // 2
25
  for i := 0; i < t.NumField(); i++ {
26
    field := t.Field(i)
27
    fmt.Printf("name:%s index:%d type:%v json tag:%v\n", field.Name, field.Index, field.Type, field.Tag.Get("zhoulin"))
28
  }
29

30
  // 通过字段名获取指定结构体字段信息
31
  if scoreField, ok := t.FieldByName("Score"); ok {
32
    fmt.Printf("name:%s index:%d type:%v json tag:%v\n", scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"))
33
  }
34
}