https://blog.csdn.net/weixin_45193103/article/details/123876319
https://blog.csdn.net/qq_49723651/article/details/122005291
https://juejin.cn/post/7005465902804123679
学一点,整一点,基本都是综合别人的,弄成我能理解的内容
Tag定义
Tag用于标识结构体字段的额外属性,有点类似于注释。标准库reflect包中提供了操作Tag的方法
Tag是结构体在编译阶段关联到成员的元信息字符串,在运行的时候通过反射的机制读取出来。
结构体的字段的定义。在reflect包中,使用结构体structField表示结构体的一个字段
type StructField struct {Name string//字段名Type Type//字段类型Tag StructTag //Tag 的类型为structTag,实际上它是一个string类型的别名//Tag
}
key会指定反射的解析方式,如下: json(JSON标签) 、orm(Beego标签)、gorm(GORM标签)、bson(MongoDB标签)、form(表单标签)、binding(表单验证标签)、yaml
Tag的意义
Go语言的反射特性可以动态地给结构体成员赋值,正是因为有Tag,在赋值前可以使用Tag来决定赋值的动作。
比如,官方的encoding/json包可以将一个JSON 数据“Unmarshal”进一个结构体,此过程中就使用了 Tag。该包定义了一些Tag 规则,只要参考该规则设置tag 就可以将不同的JSON数据转换成结构体。
在Golang中,命名都是推荐用驼峰方式,并且在首字母大小写有特殊的语法含义:包外无法引用。但是由于经常需要和其它的系统进行数据交互,例如转成json格式,存储到mongodb啊等等。这个时候如果用属性名来作为键值可能不一定会符合项目要求。
而通过Tag,我们可以在转换成其它格式的时候,使用其中定义的字段作为键值。
type User struct {UserId int `json:"user_id"`UserName string `json:"user_name"`
}
func main() {u := &User{UserId: 1, UserName: "张三"}j, _ := json.Marshal(u)fmt.Println(string(j))
}//{"user_id":1,"user_name":"张三"}
Tag约定
结构体标签由一个或多个键值对组成。键与值使用冒号分隔,值用双引号括起来。键值对之间使用一个空格分隔,具体的格式如下:
`key1:"value1" key2:"value2" key3:"value3"...` // 键值对用空格分隔
Tag 本身是一个字符串,单从语义上讲,任意的字符串都是合法的。但它有一个约定的格式,那就是字符串由key:"value"
组成。
key 必须是非空字符串,字符串不能包含控制字符、空格、引号、冒号;
value 以双引号标记的字符串。
注意: key和 value之间使用冒号分隔,冒号前后不能有空格,多个key : "value"之间由空格分开。
Kind string `json:"kind, omitempty" protobuf:"bytes,1, opt, name=kind"`
key一般表示用途,比如.json表示用于控制结构体类型与JSON格式数据之间的转换,protobuf表示用于控制序列化和反序列化。value一般表示控制指令,具体控制指令由不同的库指定。
获取Tag值
package mainimport ("fmt""reflect"
)type Food struct {Apple string `fruit:"apple"`Tomato string `vegetable:"tomato"`
}func main() {t := reflect.TypeOf(Food{})f, _ := t.FieldByName("Apple")fmt.Println(f.Tag)// Tag.Lookupv, ok := f.Tag.Lookup("fruit")fmt.Printf("%s, %t\n", v, ok)// Tag.Getv = f.Tag.Get("fruit")fmt.Println(v)
}
运行结果
fruit:"apple"
apple, true
apple
json Tag
type Student struct {ID int `json:"-"` // 该字段不进行序列化Name string `json:name,omitempy` // 如果为类型零值或空值,序列化时忽略该字段Age int `json:age,string` // 重新指定字段类型,支持string、number、boolen
}
https://studygolang.com/static/pkgdoc/pkg/encoding_json.htm
json编码
type User struct {ID int `json:"id"` // 编码后的字段名为 idName string // 编码后的字段名为 自定义成员名 Nameage int // 未导出字段不能编码
}
在 Go 语言中,如果一个结构体的字段名首字母是大写,那么它就是一个 “导出字段”(Exported Field),意味着它可以被外部的包访问和操作。反之,如果一个字段名首字母是小写,那么它就是一个 “未导出字段”(Unexported Field),只能在当前的包内部被访问和操作。
在进行 JSON 编码(encoding)或解码(decoding)时,只有结构体的导出字段才会被处理。
gorm
GORM Tag名大小写不敏感,建议使用camelCase风格,多个标签定义用分号(;)分隔
// 新闻模型
type News struct {ModelTitle string `gorm:"column:title;type:string;not null,default:''"`Content Content `gorm:"foreignKey:NewsId" json:"content"` //指定外键
}
// AUTO_INCREMENT 不生效
Id uint64 `gorm:"column:id;primaryKey;type:bigint(20);autoIncrement;comment:'主键'"`
// AUTO_INCREMENT 不生效
Id uint64 `gorm:"column:id;type:bigint(20);autoIncrement;comment:'主键'"`
// AUTO_INCREMENT 生效 gorm会自动根据字段类型设置数据库字段类型并设置为主键
Id uint64 `gorm:"column:id;autoIncrement;comment:'主键'"` //写成AUTO_INCREMENT也可以
yaml inline
在 Go 语言结构体标签(struct tags)中,yaml:",inline"
是一种特殊的标识符,表示“内联”,也就是嵌入。
这个标识符的作用主要有两层含义:
- 对于 Go 语言的结构体字段(Struct Fields)本身,如果这个字段的类型是另一个结构体,那么在编组和解组这个结构体的时候,它的字段会被当作是外层结构体的字段来处理。
- 对于解析 YAML 文件时,如果一个字段被标记为 inline,那么在这个 YAML 文件被解析成 Go 语言结构体的时候,这个字段将会把它的子节点看作是自己的直接字段。
type Person struct {Name string `yaml:"name"`Age int `yaml:"age"`
}type Employee struct {Person `yaml:",inline"`Job string `yaml:"job"`
}
当你在解析如下的 YAML 时:
yaml
name: Mike
age: 30
job: engineer
那么,这个 YAML 将会被解析成如下的 Go 语言结构体:
Employee{Person: Person{Name: "Mike",Age: 30,},Job: "engineer",
}
可以看到,虽然 YAML 文件中并没有 Person 这一层,但是由于 Person 被标记为 inline,Name 和 Age 字段就像是 Employee 的直接字段一样被处理了。
xml
func ExampleMarshalIndent() {type Address struct {City, State string}type Person struct {XMLName xml.Name `xml:"person"`Id int `xml:"id,attr"`FirstName string `xml:"name>first"`LastName string `xml:"name>last"`Age int `xml:"age"`Height float32 `xml:"height,omitempty"`Married boolAddressComment string `xml:",comment"`}v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}v.Comment = " Need more details. "v.Address = Address{"Hanga Roa", "Easter Island"}output, err := xml.MarshalIndent(v, " ", " ")if err != nil {fmt.Printf("error: %v\n", err)}os.Stdout.Write(output)// Output:// <person id="13">// <name>// <first>John</first>// <last>Doe</last>// </name>// <age>42</age>// <Married>false</Married>// <City>Hanga Roa</City>// <State>Easter Island</State>// <!-- Need more details. -->// </person>
}func ExampleEncoder() {type Address struct {City, State string}type Person struct {XMLName xml.Name `xml:"person"`Id int `xml:"id,attr"`FirstName string `xml:"name>first"`LastName string `xml:"name>last"`Age int `xml:"age"`Height float32 `xml:"height,omitempty"`Married boolAddressComment string `xml:",comment"`}v := &Person{Id: 13, FirstName: "John", LastName: "Doe", Age: 42}v.Comment = " Need more details. "v.Address = Address{"Hanga Roa", "Easter Island"}enc := xml.NewEncoder(os.Stdout)enc.Indent(" ", " ")if err := enc.Encode(v); err != nil {fmt.Printf("error: %v\n", err)}// Output:// <person id="13">// <name>// <first>John</first>// <last>Doe</last>// </name>// <age>42</age>// <Married>false</Married>// <City>Hanga Roa</City>// <State>Easter Island</State>// <!-- Need more details. -->// </person>
}// This example demonstrates unmarshaling an XML excerpt into a value with
// some preset fields. Note that the Phone field isn't modified and that
// the XML <Company> element is ignored. Also, the Groups field is assigned
// considering the element path provided in its tag.
func ExampleUnmarshal() {type Email struct {Where string `xml:"where,attr"`Addr string}type Address struct {City, State string}type Result struct {XMLName xml.Name `xml:"Person"`Name string `xml:"FullName"`Phone stringEmail []EmailGroups []string `xml:"Group>Value"`Address}v := Result{Name: "none", Phone: "none"}data := `<Person><FullName>Grace R. Emlin</FullName><Company>Example Inc.</Company><Email where="home"><Addr>gre@example.com</Addr></Email><Email where='work'><Addr>gre@work.com</Addr></Email><Group><Value>Friends</Value><Value>Squash</Value></Group><City>Hanga Roa</City><State>Easter Island</State></Person>`err := xml.Unmarshal([]byte(data), &v)if err != nil {fmt.Printf("error: %v", err)return}fmt.Printf("XMLName: %#v\n", v.XMLName)fmt.Printf("Name: %q\n", v.Name)fmt.Printf("Phone: %q\n", v.Phone)fmt.Printf("Email: %v\n", v.Email)fmt.Printf("Groups: %v\n", v.Groups)fmt.Printf("Address: %v\n", v.Address)// Output:// XMLName: xml.Name{Space:"", Local:"Person"}// Name: "Grace R. Emlin"// Phone: "none"// Email: [{home gre@example.com} {work gre@work.com}]// Groups: [Friends Squash]// Address: {Hanga Roa Easter Island}
}
Go vet
vet 是 golang 中自带的静态分析工具,可以让我们检查出 package 或者源码文件中一些隐含的错误
Go 编译器没有强制执行传统的 struct 标签格式,但是 vet 就是这样做的,所以值得使用它,例如作为 CI 管道的一部分。
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
//在 Go 语言中,当你使用结构体标签(struct tag)去描述一个结构体中的字段时,其格式必须严格遵守 "键:值"("key:value")的形式。type T struct {Name string "json:Name"
}
$ go vet
# command-line-arguments
./main.go:8: struct field tag "json:Name" not compatible with reflect.StructTag.Get: bad syntax for struct tag value//JSON 标签的字段名 Name 是以大写字符开始的,这不符合 Go 语言的标准