Golang struct结构
结构struct
- Go中的struct与C中的struct非常相似，并且Go没有class，代替了class的位置，但并没有代替class的功能
- 使用type
struct{} 定义结构，名称遵循可见性规则 - 支持指向自身的指针类型成员
- 支持匿名结构，可用作成员或定义成员变量
- 匿名结构也可以用于map的值
- 可以使用字面值对结构进行初始化
- 允许直接通过指针来读写结构成员
- 相同类型的成员可进行直接拷贝赋值
- 支持==与!=比较运算符，但不支持>或<
- 支持匿名字段，本质上是定义了以某个类型名为名称的字段
- 嵌入结构作为匿名字段看起来像继承，但不是继承
- 可以使用匿名字段指针
- tag是结构体的元信息，可以在运行的时候通过反射机器读取出来；字段类型的后面，以反引号扩起来的key-value结构的字符串，多个tag以逗号隔开。
结构的定义
package main
import (
"fmt"
)
type Person struct { //结构也是一中类型
Name string //定义struct的属性
Age int
}
func main() {
a := Person{}
a.Name = "joe" //对struct的属性进行操作，类型与class的使用方法
a.Age = 19
fmt.Println(a)
}
字面值初始化
package main
import (
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
a := Person{
Name: "jack",
Age: 19, //对结构的属性进行字面值的初始化
}
fmt.Println(a)
}
结构的传递
package main
import (
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
a := Person{
Name: "jack",
Age: 19, //对结构的属性进行字面值的初始化
}
fmt.Println(a)
A(a)
fmt.Println(a) //结构也是一种值类型，对它进行传递的时候，也是进行了值得拷贝
}
func A(per Person) {
per.Age = 13
fmt.Println("A", per)
}
PS G:\mygo\src\mytest> go run .\temp.go
{jack 19}
A {jack 13}
{jack 19}
package main
import (
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
a := Person{
Name: "jack",
Age: 19, //对结构的属性进行字面值的初始化
}
fmt.Println(a)
A(&a)
fmt.Println(a) //结构也是一种值类型，对它进行传递的时候，也是进行了值得拷贝
}
func A(per *Person) { //通过一个指针进行传递，此时就不是值得拷贝了
per.Age = 13
fmt.Println("A", per)
}
PS G:\mygo\src\mytest> go run .\temp.go
{jack 19}
A &{jack 13}
{jack 13}
package main
import (
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
a := &Person{
Name: "jack",
Age: 19, //此时初始化的时候就将这个struct的指针取出来
}
//在进行struct的初始化的时候，就加上&取地址符号
fmt.Println(a)
A(a)
B(a)
fmt.Println(a) //结构也是一种值类型，对它进行传递的时候，也是进行了值得拷贝
}
func A(per *Person) { //通过一个指针进行传递，此时就不是值得拷贝了
per.Age = 13
fmt.Println("A", per)
}
func B(per *Person) { //通过一个指针进行传递，此时就不是值得拷贝了
per.Age = 15
fmt.Println("B", per)
}
PS G:\mygo\src\mytest> go run .\temp.go
&{jack 19}
A &{jack 13}
B &{jack 15}
&{jack 15}
匿名结构
package main
import (
"fmt"
)
func main() {
a := &struct { //匿名结构，需要先对结构本身进行一个定义
Name string
Age int
}{
Name: "jack",
Age: 20,
}
fmt.Println(a)
}
匿名结构的嵌套
package main
import (
"fmt"
)
type Person struct {
Name string
Age int
Contact struct {
Phone, City string //匿名结构嵌套在Person中
}
}
func main() {
a := Person{Name: "Jack", Age: 20}
a.Contact.Phone = "123321" //通过这种方法对嵌套在Person中的匿名结构进行字面值的初始化
a.Contact.City = "BeiJing"
fmt.Println(a)
}
PS G:\mygo\src\mytest> go run .\temp2.go
{Jack 20 {123321 BeiJing}}
匿名字段
package main
import (
"fmt"
)
type Person struct {
string //匿名字段 在进行字面值初始化的时候 必须严格按照字段声明的顺序
int
}
func main() {
a := Person{"Jack", 20} //此时将string 和 int类型对调的时候就会报错
fmt.Println(a)
}
结构相同类型的比较
package main
import (
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
a := Person{Name: "Jack", Age: 20}
b := Person{Name: "Jack", Age: 20}
fmt.Println(a == b)
}
PS G:\mygo\src\mytest> go run .\temp3.go
true
嵌入结构
package main
import (
"fmt"
)
type human struct {
Sex int
}
type teacher struct {
human
Name string
Age int
}
type student struct {
human //这里的human也是一种类型，此时它相当于一种匿名字段，嵌入结构作为匿名字段的话
//它本质上是将结构名称作为我们的字段名称
Name string
Age int
}
func main() {
a := teacher{Name: "Jack", Age: 20, human: human{Sex: 0}} //因此我们需要在这里进行这种初始化
b := student{Name: "Tom", Age: 19, human: human{Sex: 1}}
a.Name = "Fack"
a.Age = 13
a.human.Sex = 100 //保留这种调用的方法，是因为会涉及到名称的冲突
//a.Sex = 101 这种写法也是可以的
fmt.Println(a, b)
}
PS G:\mygo\src\mytest> go run .\temp3.go
{{100} Fack 13} {{1} Tom 19}
tag的详解
package main
import (
"encoding/json"
"fmt"
)
type User struct {
Username string `json:"username"`
Sex string `json:"sex"`
Age int
AvatarUrl string
}
func main() {
user := &User{
Username: "user01",
Sex: "男",
Age: 18,
AvatarUrl: "http://xxx.xxx.com/xxx.png",
}
data, _ := json.Marshal(user)
fmt.Printf("json str:%s\n", string(data))
}
