我们可以通过Tag来增强结构体的定义，Tag会带上一些meta信息，在本文中我们将通过几个例子来深入了解Tag的用法。
结构
Struct是由一组field组成，每个field包括了名字(可选)和字段类型
package main
import "fmt"
type T1 struct {
f1 string
}
type T2 struct {
T1
f2 int64
f3, f4 float64
}
func main() {
t := T2{T1{"foo"}, 1, 2, 3}
fmt.Println(t.f1) // foo
fmt.Println(t.T1.f1) // foo
fmt.Println(t.f2) // 1
}
field T1是一个嵌入型field， 它并没有字段名 。Field定义可以像f3和f4一样公用一个字段类型。
标签
有时候会在字段定义后面带上一个字符串(tag)。类似于如下
type T struct {
f1 string "f one"
f2 string
f3 string `f three`
f4, f5 int64 `f four and five`
}
不管是raw string还是interpreted string都可以用来当tag。 如果field定义时候两个名字公用一个属性，那么这个tag会被附在两个名字上，像f4,f5一样。
反射
Tag在运行时可以通过reflection包来读取
package main
import (
"fmt"
"reflect"
)
type T struct {
f1 string "f one"
f2 string
f3 string `f three`
f4, f5 int64 `f four and five`
}
func main() {
t := reflect.TypeOf(T{})
f1, _ := t.FieldByName("f1")
fmt.Println(f1.Tag) // f one
f4, _ := t.FieldByName("f4")
fmt.Println(f4.Tag) // f four and five
f5, _ := t.FieldByName("f5")
fmt.Println(f5.Tag) // f four and five
}
设置一个空tag和不设置tag的效果一致
type T struct {
f1 string ``
f2 string
}
func main() {
t := reflect.TypeOf(T{})
f1, _ := t.FieldByName("f1")
fmt.Printf("%q\n", f1.Tag) // ""
f2, _ := t.FieldByName("f2")
fmt.Printf("%q\n", f2.Tag) // ""
}
格式
Tags可以由键值对来组成，通过空格符来分割键值 —key1:"value1" key2:"value2" key3:"value3"。如果Tags格式没问题的话，我们可以通过Lookup或者Get来获取键值对的值。
Lookup回传两个值 —对应的值和是否找到
type T struct {
f string `one:"1" two:"2"blank:""`
}
func main() {
t := reflect.TypeOf(T{})
f, _ := t.FieldByName("f")
fmt.Println(f.Tag) // one:"1" two:"2"blank:""
v, ok := f.Tag.Lookup("one")
fmt.Printf("%s, %t\n", v, ok) // 1, true
v, ok = f.Tag.Lookup("blank")
fmt.Printf("%s, %t\n", v, ok) // , true
v, ok = f.Tag.Lookup("five")
fmt.Printf("%s, %t\n", v, ok) // , false
}
Get方法只是简单的包装了以下Lookup。但是丢弃了是否成功结果
func (tag StructTag) Get(key string) string {
v, _ := tag.Lookup(key)
return v
}
转化
将结构体的值转化成其他的类型可通过Tag来定义
type T1 struct {
f int `json:"foo"`
}
type T2 struct {
f int `json:"bar"`
}
t1 := T1{10}
var t2 T2
t2 = T2(t1)
fmt.Println(t2) // {10}
什么时候用到了Tag
(Un)marshaling
Tag最常用的大概就是在marshaling。
import (
"encoding/json"
"fmt"
)
func main() {
type T struct {
F1 int `json:"f_1"`
F2 int `json:"f_2,omitempty"`
F3 int `json:"f_3,omitempty"`
F4 int `json:"-"`
}
t := T{1, 0, 2, 3}
b, err := json.Marshal(t)
if err != nil {
panic(err)
}
fmt.Printf("%s\n", b) // {"f_1":1,"f_3":2}
}
ORM
比如说GORM— example.
go vet
go的编译器不会强行要求你使用合理的tags。但是 go vet可以检查出你的tag是否合理。
package main
type T struct {
f string "one two three"
}
func main() {}
> go vet tags.go
tags.go:4: struct field tag `one two three` not compatible with reflect.StructTag.Get: bad syntax for struct tag pair
