Go-知识struct
- 1. struct 的定义
- 1.1 定义字段
- 1.2 定义方法
- 2. struct的复用
- 3. 方法受体
- 4. 字段标签
- 4.1 Tag是Struct的一部分
- 4.2 Tag 的约定
- 4.3 Tag 的获取
githupio地址：https://a18792721831.github.io/
1. struct 的定义
Go 语言的struct与Java中的class类似，可以定义字段和方法，但是不能继承。
1.1 定义字段
struct定义字段非常简单，只需要将字段写在struct的结构中，比如：
type tes struct {
a int
Name string
}
需要注意的是，在Go里面，访问权限是通过name的大小写指定的，小写表示包内可见，如果是大写则表示包外可见。
所以上面的struct如果用Java翻译：
class tes {
private int a;
public String Name;
}
同样的，如果创建的struct想让包外可见，那么必须是大写开头。
type Tes struct{
id int
Name string
}
1.2 定义方法
在Go里面一般不会区分函数和方法，或者更好理解的话，可以认为方法是受限的函数，限制了函数调用者，那么就是方法。
定义方法：
func (a tes) test() {
fmt.Println(a.id)
}
同样的，上述方法包内可见。
func (a tes) Test() {
fmt.Println(a.Name)
}
上述方法虽然包外可见，但是没有意义，因为tes是包内可见，如果没有对外提供函数，那么是没有意义的。
如果想保证安全，可以使用包内可见的struct配合包内字段加包外方法，另外额外提供包外可见的struct获取函数，实现类似于Java的可见性控制。
package tes
type person struct {
id int
name string
age int
}
func (this *person) GetId() int {
return this.id
}
func (this *person) GetName() string {
return this.name
}
func (this *person) GetAge() int {
return this.age
}
func (this *person) SetId(id int) {
this.id = id
}
func (this *person) SetName(name string) {
this.name = name
}
func (this *person) SetAge(age int) {
this.age = age
}
func NewPerson() *person {
return &person{}
}
func NewPersonWithId(id int) *person {
return &person{id: id}
}
func NewPersonWithName(name string) *person {
return &person{name: name}
}
因为Go不支持函数重载，所以需要用不同的函数名字区分。
上述代码实际上就是一个基本的JavaBean的实现。
但是实际使用上，基本上对外可见的字段都是直接用.来访问和赋值的。
在使用上，struct是否对外可见，则和编码风格相关，业务系统一般不会考虑封闭性，基本上struct都是可见的；而第三方包等为了保证安全性，则会将部分struct设置为包内可见，在结合interface来保证扩展性。
2. struct的复用
在其他编程语言中，使用继承或组合实现代码的复用。
而Go语言中没有继承，只能使用组合实现复用。
比较特别的是，在Go语言中，组合复用的struct可以认为拷贝了被组合的struct的字段到需要的struct中。
type Man struct {
person
sex string
}
func (this *Man) ToString() string {
return fmt.Sprintf("id=%d, name=%s, age=%d, sex=%s\n", this.person.id, this.person.name, this.person.age, this.sex)
}
func (this *Man) GetToString() string {
return fmt.Sprintf("id=%d, name=%s, age=%d, sex=%s\n", this.id, this.name, this.age, this.sex)
}
在struct中组合其他struct，相当于是创建了一个同名的隐式字段，在使用的时候，可以指明隐式字段，也可以不指明隐式字段。
想一想，在Java中，如果当前class和父class中有同名的字段，那么在使用父类中的字段时，需要使用super指明使用的是父类中的字段。
同理的，当struct中有一个id，那么在使用的时候，可以使用隐式字段指明：
type Man struct {
id int
person
sex string
}
func (this *Man) GetSuperId() int {
return this.person.id
}
func (this *Man) GetManId() int {
return this.id
}
隐式字段如果显示的定义了，那么就无法像使用自己的字段一样使用内嵌字段了：
type Woman struct {
person person
sex string
}
func (this *Woman) ToString() string {
return fmt.Sprintf("id=%d, name=%s, age=%d, sex=%s\n", this.person.id, this.person.name, this.person.age, this.sex)
}
func (this *Woman) GetString() string {
return fmt.Sprintf("id=%d, name=%s, age=%d, sex=%s\n", this.id)
}
如果还像使用自己的字段一样使用内嵌字段，就会找不到
3. 方法受体
方法本质上还是函数，只是限制了函数的调用者。
那么你有没有好奇，为什么上面的例子中，方法的调用者都是指针类型而不是struct类型，这有什么区别?
type person struct {
id int
name string
age int
}
func (this *person) SetIdPtr(id int) {
this.id = id
}
func (this person) SetId(id int) {
this.id = id
}
func (this *person) GetIdPtr() int {
return this.id
}
func (this person) GetId() int {
return this.id
}
func TestPerson(t *testing.T) {
p := person{
id: 1,
name: "zhangsan",
age: 10,
}
fmt.Printf("%+v\n", p)
p.SetId(2)
fmt.Printf("%+v\n", p)
p.SetIdPtr(3)
fmt.Printf("%+v\n", p)
p.id = 4
fmt.Printf("%+v\n", p.GetIdPtr())
p.id = 5
fmt.Printf("%+v\n", p.GetId())
}
没错，区别在于是否会影响原数据。
函数调用过程中，会将函数压入调用栈，在入栈过程中，会对函数参数进行拷贝。
在Java中，如果是基本类型参数，那么拷贝值，如果是复杂类型参数，那么拷贝指针。
在Go语言中，可以由程序员指定，如果方法调用者是指针，那么表示方法可以修改外部数据，如果方法调用者是struct，那么不会修改外部数据。
如果是数据的读取，那么不管是指针还是struct，都能读取到数据。
在换一个角度看，方法的调用者，在方法调用的时候，也进行了参数拷贝，所以可以认为方法调用者就是一个特殊的参数。
type person struct {
id int
name string
age int
}
func (this person) GetNameS() string {
return this.name
}
func GetName(this *person) string {
return this.name
}
func TestPerson(t *testing.T) {
p := person{
id: 1,
name: "zhangsan",
age: 10,
}
fmt.Println(p.GetNameS())
fmt.Println(GetName(&p))
}
运行都能获取到结果
只是无法使用.的方式触发了。
4. 字段标签
在Go语言的struct的字段后面，可以使用标签。
type person struct {
id int `tagKey:"tagValue1,tageValue2"`
name string `tagKey:"tagValue1,tageValue2"`
age int `tagKey:"tagValue1,tageValue2"`
}
4.1 Tag是Struct的一部分
Tag用于标识字段的额外属性，类似注释。标准库reflect包中提供了操作Tag的方法。
// A StructField describes a single field in a struct.
type StructField struct {
// Name is the field name.
Name string
// PkgPath is the package path that qualifies a lower case (unexported)
// field name. It is empty for upper case (exported) field names.
// See https://golang.org/ref/spec#Uniqueness_of_identifiers
PkgPath string
Type Type // field type
Tag StructTag // field tag string
Offset uintptr // offset within struct, in bytes
Index []int // index sequence for Type.FieldByIndex
Anonymous bool // is an embedded field
}
而StructTag其实就是字符串:
4.2 Tag 的约定
Tag本质上是个字符串，那么任何字符串都是合法的，但是在实际使用中，有一个约定：key:"value.."格式，如果有多个，中间用空格区分。
type person struct {
id int `tagKey:"tagValue1,tageValue2" tagKey1:"tagValue1,tageValue2"`
name string `tagKey:"tagValue1,tageValue2" tagKey1:"tagValue1,tageValue2"`
age int `tagKey:"tagValue1,tageValue2" tagKey1:"tagValue1,tageValue2"`
}
key: 必须是非空字符串，字符串不能包含控制字符、空格、引号、冒号。
value: 以双引号标记的字符串。
key和value之间使用冒号分割，冒号前后不能有空格。
多个key-value之间用空格分割。
key一般用于表示用途，value一般表示控制指令。
比如：
json:"name,omitempty"
表示json转换的时候，使用name作为名字，如果字段值为空，那么json转换该字段的时候忽略。
4.3 Tag 的获取
在reflect的StructField提供了Get和Lookup方法：
比如获取上面person的Tag
func TestPerson(t *testing.T) {
p := person{
id: 1,
name: "zhangsan",
age: 10,
}
st := reflect.TypeOf(p)
stf, ok := st.FieldByName("id")
if !ok {
fmt.Println("not found")
return
}
nameTag := stf.Tag
fmt.Printf("tagKey=%s\n", nameTag.Get("tagKey"))
tagValue, ok := nameTag.Lookup("tagKey1")
if !ok {
fmt.Println("not found")
return
}
fmt.Printf("tagKey1=%s\n", tagValue)
}
在Java中有一个非常强大，也经常使用的插件lombok，通过在class的字段上添加注解，进而实现一些控制方法。
区别在于，lombok是在编译时，通过操作字节码，实现方法的写入，而Tag是在运行时，通过反射赋值。
所以Tag只能操作已有的字段和函数，不能动态的增加或者减少字段和函数。
除了使用第三方库，借助上述语法，自己也可以定义需要的操作比如判空。
