golang结构体

2024-05-22 11:54:12 88

什么是结构体

结构体（struct）是用户自定义的类型，它代表若干字段的集合。有些时候将多个数据看做一个整体要比单独使用这些数据更有意义，这种情况下就适合使用结构体。

比如将一个员工的firstName,lastName和age三个属性打包在一起成为一个employee结构就是很有意义的。

结构体的声明

typeEmployeestruct{
firstNamestring
lastNamestring
ageint
}12345

上面的代码片段声明了一个名为Employee的结构体类型，它拥有firstName,lastName和age三个字段。同一类型的多个字段可以合并到一行（用逗号分隔），并将类型放在后面。上面的结构体中firstName与lastName都是string类型，因此可以将它们写在一起。

typeEmployeestruct{
firstName,lastNamestring
age,salaryint
}1234

上面的结构体Employee是一个具名结构体（namedstructure），因为它创建了一个具有名字的结构体类型：Employee。我们可以定义具名结构体类型的变量。

我们也可以定义一个没有类型名称的结构体，这种结构体叫做匿名结构体（anonymousstructures）。

varemployeestruct{
firstName,lastNamestring
ageint
}1234

上面的代码片段声明了一个匿名结构体变量employee。

定义具名结构体变量

下面的程序说明了如何定义一个具名结构体Employee的变量。

packagemain

import(
"fmt"
)

typeEmployeestruct{
firstName,lastNamestring
age,salaryint
}

funcmain(){

//creatingstructureusingfieldnames
emp1:=Employee{
firstName:"Sam",
age:25,
salary:500,
lastName:"Anderson",
}

//creatingstructurewithoutusingfieldnames
emp2:=Employee{"Thomas","Paul",29,800}

fmt.Println("Employee1",emp1)
fmt.Println("Employee2",emp2)
}123456789101112131415161718192021222324252627

在上面的程序中，我们定义了一个名为Employee的结构体类型。我们可以通过指定字段的名称和对应的值来创建一个结构体变量，比如在第15行，我们就是通过这种方式定义了Employee类型的一个结构体变量empl。这里字段名称的顺序没必要和声明结构体类型时的一致。例如这里我们将lastName放在了最后，程序同样正确运行。

在定义结构体变量时也可以忽略字段名称，例如在第23行，我们定义emp2时没有指定字段名称。但是通过这种方式定义的结构体变量时，字段值的顺序必须与声明结构体类型时字段的顺序保持一致。

上面的程序输出如下：

Employee1{SamAnderson25500}
Employee2{ThomasPaul29800}12

定义匿名结构体变量

packagemain

import(
"fmt"
)

funcmain(){
emp3:=struct{
firstName,lastNamestring
age,salaryint
}{
firstName:"Andreah",
lastName:"Nikola",
age:31,
salary:5000,
}

fmt.Println("Employee3",emp3)
}12345678910111213141516171819

在上面的程序中，第3行定义了一个匿名结构体变量emp3。正如我们提到的一样，这种结构体成为匿名结构体，因为它只创建了一个新的结构体变量emp3，而没有定义新的结构体类型。

程序的输出为：

Employee3{AndreahNikola315000}1

结构体变量的0值

当定义一个结构体变量，但是没有给它提供初始值，则对应的字段被赋予它们各自类型的0值。

packagemain

import(
"fmt"
)

typeEmployeestruct{
firstName,lastNamestring
age,salaryint
}

funcmain(){
varemp4Employee//zerovaluedstructure
fmt.Println("Employee4",emp4)
}
12345678910111213141516

上面的程序定义了emp4但是没有赋予任何初值。因此firstName和lastName被赋值为string类型的0值，也就是空字符串。age和salary被赋值为int类型的0值，也就是0。程序的输出为：

Employee4{00}1

可以指定一些字段而忽略一些字段。在这种情况下，被忽略的字段被赋予相应类型的0值。

packagemain

import(
"fmt"
)

typeEmployeestruct{
firstName,lastNamestring
age,salaryint
}

funcmain(){
emp5:=Employee{
firstName:"John",
lastName:"Paul",
}
fmt.Println("Employee5",emp5)
}123456789101112131415161718

在上面的程序中，第14和15行，firstName和lastName被提供了初始值，而age和salary没有。因此age和salary被指定为0值。程序的输出为：

Employee5{JohnPaul00}1

访问结构体中的字段

使用点.操作符来访问结构体中的字段。

packagemain

import(
"fmt"
)

typeEmployeestruct{
firstName,lastNamestring
age,salaryint
}

funcmain(){
emp6:=Employee{"Sam","Anderson",55,6000}
fmt.Println("FirstName:",emp6.firstName)
fmt.Println("LastName:",emp6.lastName)
fmt.Println("Age:",emp6.age)
fmt.Printf("Salary:$%d",emp6.salary)
}123456789101112131415161718

在上面的程序中，通过emp6.firstName访问emp6中的字段firstName。程序的输出为：

FirstName:Sam
LastName:Anderson
Age:55
Salary:$60001234

也可以创建一个0值结构体变量，稍后给它的字段一一赋值。

packagemain

import(
"fmt"
)

typeEmployeestruct{
firstName,lastNamestring
age,salaryint
}

funcmain(){
varemp7Employee
emp7.firstName="Jack"
emp7.lastName="Adams"
fmt.Println("Employee7:",emp7)
}1234567891011121314151617

上面的程序emp7被定义然后给firstName和lastName赋值。程序的输出为：

Employee7:{JackAdams00}1

结构体指针

可以定义指向结构体的指针。

packagemain

import(
"fmt"
)

typeEmployeestruct{
firstName,lastNamestring
age,salaryint
}

funcmain(){
emp8:=&Employee{"Sam","Anderson",55,6000}
fmt.Println("FirstName:",(*emp8).firstName)
fmt.Println("Age:",(*emp8).age)
}12345678910111213141516

在上面的程序中emp8是一个指向结构体Employee的指针。(*emp8).firstName是访问emp8中firstName字段的语法。程序的输出为：

FirstName:Sam
Age:5512

在Go中我们可以使用emp8.firstName替代显示解引用(\*emp8).firstName来访问firstName字段。

packagemain

import(
"fmt"
)

typeEmployeestruct{
firstName,lastNamestring
age,salaryint
}

funcmain(){
emp8:=&Employee{"Sam","Anderson",55,6000}
fmt.Println("FirstName:",emp8.firstName)
fmt.Println("Age:",emp8.age)
}12345678910111213141516

在上面的程序中，我们使用了emp8.firstName访问firstName，程序的输出如下：

FirstName:Sam
Age:5512

匿名字段

定义结构体类型时可以仅指定字段类型而不指定字段名字。这种字段叫做匿名字段（anonymousfield）。

下面的程序片段创建了一个Person结构体，它有两个匿名字段，类型为string和int。

typePersonstruct{
string
int
}1234

让我们写一个使用匿名字段的程序。

packagemain

import(
"fmt"
)

typePersonstruct{
string
int
}

funcmain(){
p:=Person{"Naveen",50}
fmt.Println(p)
}123456789101112131415

在上面的程序中，Person是一个具有两个匿名字段的结构体类型。p:=Person{"Naveen",50}定义了Person的一个变量。程序的输出为：{Naveen50}。

**虽然匿名字段没有名字，但是匿名字段的默认名字为类型名。**比如上面的Person类型，尽管它的字段是匿名的，但是默认它们拥有它们的类型的名字。因此Person结构体有两个名为string和int的字段。

packagemain

import(
"fmt"
)

typePersonstruct{
string
int
}

funcmain(){
varp1Person
p1.string="naveen"
p1.int=50
fmt.Println(p1)
}1234567891011121314151617

在上面的程序中，第14和15行，我们通过使用匿名字段的类型名（"string"和"int"）来访问Person结构体的字段。程序的输出为：

{naveen50}1

结构体嵌套

结构体的字段也可以是一个结构体。这种结构体称为嵌套结构体。

packagemain

import(
"fmt"
)

typeAddressstruct{
city,statestring
}
typePersonstruct{
namestring
ageint
addressAddress
}

funcmain(){
varpPerson
p.name="Naveen"
p.age=50
p.address=Address{
city:"Chicago",
state:"Illinois",
}
fmt.Println("Name:",p.name)
fmt.Println("Age:",p.age)
fmt.Println("City:",p.address.city)
fmt.Println("State:",p.address.state)
}12345678910111213141516171819202122232425262728

上面的程序中，Person结构体有一个字段address，而address同样也是一个结构体。程序的输出为：

Name:Naveen
Age:50
City:Chicago
State:Illinois1234

字段提阶

如果结构体中的匿名字段也是一个结构体，那么这个匿名结构体字段成为提阶字段（Promotedfields），因为可以从外部结构体变量直接访问匿名结构体类型中的字段，就像这些字段原本属于外部结构体一样。我知道这个定义可能让人很难理解，因此我们通过下面的一段代码来理解他：）

typeAddressstruct{
city,statestring
}
typePersonstruct{
namestring
ageint
Address
}12345678

上面的程序片段中，Person结构体有一个匿名字段Address，这个匿名字段也是一个结构体。现在Address中的字段city和state被称为提阶字段，因为它们就好像被直接声明在Person里一样。

packagemain

import(
"fmt"
)

typeAddressstruct{
city,statestring
}
typePersonstruct{
namestring
ageint
Address
}

funcmain(){
varpPerson
p.name="Naveen"
p.age=50
p.Address=Address{
city:"Chicago",
state:"Illinois",
}
fmt.Println("Name:",p.name)
fmt.Println("Age:",p.age)
fmt.Println("City:",p.city)//cityispromotedfield
fmt.Println("State:",p.state)//stateispromotedfield
}12345678910111213141516171819202122232425262728

上面的程序中，在第26和27行，提阶字段city和state就像它们声明在结构体变量p中一样，通过p.city和p.state的方式被访问。程序的输出如下：

Name:Naveen
Age:50
City:Chicago
State:Illinois1234

导出结构体和字段

如果一个结构体类型的名称以大写字母开头，则该结构体被导出，其他包可以访问它。同样地，如果结构体中的字段名以大写字母开头，则这些字段也可以被其他包访问。

packagecomputer

typeSpecstruct{//exportedstruct
Makerstring//exportedfield
modelstring//unexportedfield
Priceint//exportedfield
}1234567

上面的程序创建了一个包computer，该包中导出了一个结构体类型Spec，以及它的两个字段Maker和Price，它还有一个未导出字段model。让我们从另外的一个包导入这个包并使用Spec结构体。

packagemain

import"structs/computer"
import"fmt"

funcmain(){
varspeccomputer.Spec
spec.Maker="apple"
spec.Price=50000
fmt.Println("Spec:",spec)
}1234567891011

在上面的程序中，第8行和第9行，我们访问了Spec结构体的两个导出的字段Makder和Price。程序的输出为：Spec:{apple50000}。

如果我们试图访问未导出的字段model，程序将会报错。

packagemain

import"structs/computer"
import"fmt"

funcmain(){
varspeccomputer.Spec
spec.Maker="apple"
spec.Price=50000
spec.model="MacMini"
fmt.Println("Spec:",spec)
}123456789101112

上面的程序第10行，我们试图访问未导出的字段model。运行这个程序将会报错：structsamples.go:10:spec.modelundefined(cannotrefertounexportedfieldormethodmodel)。

比较结构体

结构体是值类型，如果其字段是可比较的，则该结构体就是可以比较的。如果两个结构体变量的所有非空字段都相等，则认为这两个结构体变量相等。

packagemain

import(
"fmt"
)

typenamestruct{
firstNamestring
lastNamestring
}


funcmain(){
name1:=name{"Steve","Jobs"}
name2:=name{"Steve","Jobs"}
ifname1==name2{
fmt.Println("name1andname2areequal")
}else{
fmt.Println("name1andname2arenotequal")
}

name3:=name{firstName:"Steve",lastName:"Jobs"}
name4:=name{}
name4.firstName="Steve"
ifname3==name4{
fmt.Println("name3andname4areequal")
}else{
fmt.Println("name3andname4arenotequal")
}
}123456789101112131415161718192021222324252627282930

在上面的程序中，name结构体类型包含两个string字段。因为string是可比较的，因此两个name类型的变量也是可以比较的。

在上面的程序中，name1和name2是相等的，而name3和name4是不相等的。程序的输出如下：

name1andname2areequal
name3andname4arenotequal12

如果结构体包含不可比较的类型的字段，那么这两个结构体是不可比较的。

packagemain

import(
"fmt"
)

typeimagestruct{
datamap[int]int
}

funcmain(){
image1:=image{data:map[int]int{
0:155,
}}
image2:=image{data:map[int]int{
0:155,
}}
ifimage1==image2{
fmt.Println("image1andimage2areequal")
}
}123456789101112131415161718192021

在上面的程序中，image结构体类型包含了一个字段data，该字段是map类型。map是不可比较的类型，因此image1和image2是不可比较的。如果你运行这个程序，将报错：main.go:18:invalidoperation:image1==image2(structcontainingmap[int]intcannotbecompared).。

原文链接：