Go语言中的Tag语法

Tag可以用来增强结构体的定义，Tag会带上一些meta信息，在本文中将通过几个例子来深入了解Tag的用法。

标签

有时候会在结构struct字段定义后面带上一个字符串(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} 

(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

type Blog struct {
	ID         uint   `gorm:"primary_key"`
	Locale     string `gorm:"primary_key"`
	Subject    string
	Body       string
	Tags       []Tag `gorm:"many2many:blog_tags;"`
	SharedTags []Tag `gorm:"many2many:shared_blog_tags;ForeignKey:id;AssociationForeignKey:id"`
	LocaleTags []Tag `gorm:"many2many:locale_blog_tags;ForeignKey:id,locale;AssociationForeignKey:id"`
}

type Tag struct {
	ID     uint   `gorm:"primary_key"`
	Locale string `gorm:"primary_key"`
	Value  string
	Blogs  []*Blog `gorm:"many2many:blogs_tags"`
}

func compareTags(tags []Tag, contents []string) bool {
	var tagContents []string
	for _, tag := range tags {
		tagContents = append(tagContents, tag.Value)
	}
	sort.Strings(tagContents)
	sort.Strings(contents)
	return reflect.DeepEqual(tagContents, contents)
}

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