Golang教程:(十六)结构体
2017-07-17 08:09
246 查看
原文:https://golangbot.com/structs/
欢迎来到Golang系列教程的第十六篇。
比如将一个员工的 firstName, lastName 和 age 三个属性打包在一起成为一个
上面的代码片段声明了一个名为
上面的结构体
我们也可以定义一个没有类型名称的结构体,这种结构体叫做匿名结构体(anonymous structures)。
上面的代码片段声明了一个匿名结构体变量
在上面的程序中,我们定义了一个名为
在定义结构体变量时也可以忽略字段名称,例如在第 23 行,我们定义
上面的程序输出如下:
在上面的程序中,第3行定义了一个 匿名结构体变量
程序的输出为:
上面的程序定义了
可以指定一些字段而忽略一些字段。在这种情况下,被忽略的字段被赋予相应类型的 0 值。
在上面的程序中,第14和15行,
在上面的程序中,通过 emp6.firstName 访问
也可以创建一个 0 值结构体变量,稍后给它的字段一一赋值。
上面的程序
在上面的程序中 emp8 是一个指向结构体
在 Go 中我们可以使用
在上面的程序中,我们使用了
下面的程序片段创建了一个
让我们写一个使用匿名字段的程序。
在上面的程序中,
虽然匿名字段没有名字,但是匿名字段的默认名字为类型名。比如上面的
在上面的程序中,第14和15行,我们通过使用匿名字段的类型名(
上面的程序中,
上面的程序片段中,
上面的程序中,在第 26 和 27 行,提阶字段
上面的程序创建了一个包
在上面的程序中,第 8 行和第 9 行,我们访问了
如果我们试图访问未导出的字段
上面的程序第10行,我们试图访问未导出的字段
在上面的程序中,
在上面的程序中,
如果结构体包含不可比较的类型的字段,那么这两个结构体是不可比较的。
在上面的程序中,
在 github 上可以找到本教程的代码。
结构体就介绍到这里。感谢阅读。
目录
上一篇:Golang教程:(十五)指针
下一篇:Golang教程:(十七)方法
欢迎来到Golang系列教程的第十六篇。
什么是结构体
结构体(struct)是用户自定义的类型,它代表若干字段的集合。有些时候将多个数据看做一个整体要比单独使用这些数据更有意义,这种情况下就适合使用结构体。比如将一个员工的 firstName, lastName 和 age 三个属性打包在一起成为一个
employee结构就是很有意义的。
结构体的声明
type Employee struct { firstName string lastName string age int }
上面的代码片段声明了一个名为
Employee的结构体类型,它拥有 firstName, lastName 和 age 三个字段。同一类型的多个字段可以合并到一行(用逗号分隔),并将类型放在后面。上面的结构体中
firstName与
lastName都是 string 类型,因此可以将它们写在一起。
type Employee struct { firstName, lastName string age, salary int }
上面的结构体
Employee是一个具名结构体(named structure),因为它创建了一个具有名字的结构体类型:
Employee。我们可以定义具名结构体类型的变量。
我们也可以定义一个没有类型名称的结构体,这种结构体叫做匿名结构体(anonymous structures)。
var employee struct { firstName, lastName string age int }
上面的代码片段声明了一个匿名结构体变量
employee。
定义具名结构体变量
下面的程序说明了如何定义一个具名结构体Employee的变量。
package main
import (
"fmt"
)
type Employee struct { firstName, lastName string age, salary int }
func main() {
//creating structure using field names
emp1 := Employee{
firstName: "Sam",
age: 25,
salary: 500,
lastName: "Anderson",
}
//creating structure without using field names
emp2 := Employee{"Thomas", "Paul", 29, 800}
fmt.Println("Employee 1", emp1)
fmt.Println("Employee 2", emp2)
}
在上面的程序中,我们定义了一个名为
Employee的结构体类型。我们可以通过指定字段的名称和对应的值来创建一个结构体变量,比如在第15行,我们就是通过这种方式定义了
Employee类型的一个结构体变量
empl。这里字段名称的顺序没必要和声明结构体类型时的一致。例如这里我们将
lastName放在了最后,程序同样正确运行。
在定义结构体变量时也可以忽略字段名称,例如在第 23 行,我们定义
emp2时没有指定字段名称。但是通过这种方式定义的结构体变量时,字段值的顺序必须与声明结构体类型时字段的顺序保持一致。
上面的程序输出如下:
Employee 1 {Sam Anderson 25 500} Employee 2 {Thomas Paul 29 800}
定义匿名结构体变量
package main import ( "fmt" ) func main() { emp3 := struct { firstName, lastName string age, salary int }{ firstName: "Andreah", lastName: "Nikola", age: 31, salary: 5000, } fmt.Println("Employee 3", emp3) }
在上面的程序中,第3行定义了一个 匿名结构体变量
emp3。正如我们提到的一样,这种结构体成为匿名结构体,因为它只创建了一个新的结构体变量
emp3,而没有定义新的结构体类型。
程序的输出为:
Employee 3 {Andreah Nikola 31 5000}
结构体变量的 0 值
当定义一个结构体变量,但是没有给它提供初始值,则对应的字段被赋予它们各自类型的0值。package main
import (
"fmt"
)
type Employee struct { firstName, lastName string age, salary int }
func main() {
var emp4 Employee //zero valued structure
fmt.Println("Employee 4", emp4)
}
上面的程序定义了
emp4但是没有赋予任何初值。因此
firstName和
lastName被赋值为 string 类型的0值,也就是空字符串。
age和
salary被赋值为 int 类型的0值,也就是 0 。程序的输出为:
Employee 4 { 0 0}
可以指定一些字段而忽略一些字段。在这种情况下,被忽略的字段被赋予相应类型的 0 值。
package main
import (
"fmt"
)
type Employee struct { firstName, lastName string age, salary int }
func main() {
emp5 := Employee{
firstName: "John",
lastName: "Paul",
}
fmt.Println("Employee 5", emp5)
}
在上面的程序中,第14和15行,
firstName和
lastName被提供了初始值,而
age和
salary没有。因此
age和
salary被指定为0值。程序的输出为:
Employee 5 {John Paul 0 0}
访问结构体中的字段
使用点.操作符来访问结构体中的字段。
package main
import (
"fmt"
)
type Employee struct { firstName, lastName string age, salary int }
func main() {
emp6 := Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", emp6.firstName)
fmt.Println("Last Name:", emp6.lastName)
fmt.Println("Age:", emp6.age)
fmt.Printf("Salary: $%d", emp6.salary)
}
在上面的程序中,通过 emp6.firstName 访问
emp6中的字段
firstName。程序的输出为:
First Name: Sam Last Name: Anderson Age: 55 Salary: $6000
也可以创建一个 0 值结构体变量,稍后给它的字段一一赋值。
package main
import (
"fmt"
)
type Employee struct { firstName, lastName string age, salary int }
func main() {
var emp7 Employee
emp7.firstName = "Jack"
emp7.lastName = "Adams"
fmt.Println("Employee 7:", emp7)
}
上面的程序
emp7被定义然后给
firstName和
lastName赋值。程序的输出为:
Employee 7: {Jack Adams 0 0}
结构体指针
可以定义指向结构体的指针。package main
import (
"fmt"
)
type Employee struct { firstName, lastName string age, salary int }
func main() {
emp8 := &Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", (*emp8).firstName)
fmt.Println("Age:", (*emp8).age)
}
在上面的程序中 emp8 是一个指向结构体
Employee的指针。
(*emp8).firstName是访问
emp8中
firstName字段的语法。程序的输出为:
First Name: Sam Age: 55
在 Go 中我们可以使用
emp8.firstName替代显示解引用
(*emp8).firstName来访问
firstName字段。
package main
import (
"fmt"
)
type Employee struct { firstName, lastName string age, salary int }
func main() {
emp8 := &Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", emp8.firstName)
fmt.Println("Age:", emp8.age)
}
在上面的程序中,我们使用了
emp8.firstName访问
firstName,程序的输出如下:
First Name: Sam Age: 55
匿名字段
定义结构体类型时可以仅指定字段类型而不指定字段名字。这种字段叫做匿名字段(anonymous field)。下面的程序片段创建了一个
Person结构体,它有两个匿名字段,类型为 string 和 int 。
type Person struct { string int }
让我们写一个使用匿名字段的程序。
package main
import (
"fmt"
)
type Person struct { string int }
func main() {
p := Person{"Naveen", 50}
fmt.Println(p)
}
在上面的程序中,
Person是一个具有两个匿名字段的结构体类型。
p := Person{"Naveen", 50}定义了
Person的一个变量。程序的输出为:
{Naveen 50}。
虽然匿名字段没有名字,但是匿名字段的默认名字为类型名。比如上面的
Person类型,尽管它的字段是匿名的,但是默认它们拥有它们的类型的名字。因此
Person结构体有两个名为
string和
int的字段。
package main
import (
"fmt"
)
type Person struct { string int }
func main() {
var p1 Person
p1.string = "naveen"
p1.int = 50
fmt.Println(p1)
}
在上面的程序中,第14和15行,我们通过使用匿名字段的类型名(
"string"和
"int")来访问
Person结构体的字段。程序的输出为:
{naveen 50}
结构体嵌套
结构体的字段也可以是一个结构体。这种结构体称为嵌套结构体。package main import ( "fmt" ) type Address struct { city, state string } type Person struct { name string age int address Address } func main() { var p Person 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) }
上面的程序中,
Person结构体有一个字段
address,而
address同样也是一个结构体。程序的输出为:
Name: Naveen Age: 50 City: Chicago State: Illinois
字段提阶
如果结构体中的匿名字段也是一个结构体,那么这个匿名结构体字段成为提阶字段(Promoted fields),因为可以从外部结构体变量直接访问匿名结构体类型中的字段,就像这些字段原本属于外部结构体一样。我知道这个定义可能让人很难理解,因此我们通过下面的一段代码来理解他:)type Address struct { city, state string } type Person struct { name string age int Address }
上面的程序片段中,
Person结构体有一个匿名字段
Address,这个匿名字段也是一个结构体。现在
Address中的字段
city和
state被称为提阶字段,因为它们就好像被直接声明在
Person里一样。
package main
import (
"fmt"
)
type Address struct { city, state string } type Person struct { name string age int Address }
func main() {
var p Person
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) //city is promoted field
fmt.Println("State:", p.state) //state is promoted field
}
上面的程序中,在第 26 和 27 行,提阶字段
city和
state就像它们声明在结构体变量
p中一样,通过
p.city和
p.state的方式被访问。程序的输出如下:
Name: Naveen Age: 50 City: Chicago State: Illinois
导出结构体和字段
如果一个结构体类型的名称以大写字母开头,则该结构体被导出,其他包可以访问它。同样地,如果结构体中的字段名以大写字母开头,则这些字段也可以被其他包访问。package computer type Spec struct { //exported struct Maker string //exported field model string //unexported field Price int //exported field }
上面的程序创建了一个包
computer,该包中导出了一个结构体类型
Spec,以及它的两个字段
Maker和
Price,它还有一个未导出字段
model。让我们从另外的一个包导入这个包并使用
Spec结构体。
package main import "structs/computer" import "fmt" func main() { var spec computer.Spec spec.Maker = "apple" spec.Price = 50000 fmt.Println("Spec:", spec) }
在上面的程序中,第 8 行和第 9 行,我们访问了
Spec结构体的两个导出的字段
Makder和
Price。程序的输出为:
Spec: {apple 50000}。
如果我们试图访问未导出的字段
model,程序将会报错。
package main import "structs/computer" import "fmt" func main() { var spec computer.Spec spec.Maker = "apple" spec.Price = 50000 spec.model = "Mac Mini" fmt.Println("Spec:", spec) }
上面的程序第10行,我们试图访问未导出的字段
model。运行这个程序将会报错:
structsamples.go:10: spec.model undefined (cannot refer to unexported field or method model)。
比较结构体
结构体是值类型,如果其字段是可比较的,则该结构体就是可以比较的。如果两个结构体变量的所有非空字段都相等,则认为这两个结构体变量相等。package main import ( "fmt" ) type name struct { firstName string lastName string } func main() { name1 := name{"Steve", "Jobs"} name2 := name{"Steve", "Jobs"} if name1 == name2 { fmt.Println("name1 and name2 are equal") } else { fmt.Println("name1 and name2 are not equal") } name3 := name{firstName:"Steve", lastName:"Jobs"} name4 := name{} name4.firstName = "Steve" if name3 == name4 { fmt.Println("name3 and name4 are equal") } else { fmt.Println("name3 and name4 are not equal") } }
在上面的程序中,
name结构体类型包含两个 string 字段。因为 string 是可比较的,因此两个
name类型的变量也是可以比较的。
在上面的程序中,
name1和
name2是相等的,而
name3和
name4是不相等的。程序的输出如下:
name1 and name2 are equal name3 and name4 are not equal
如果结构体包含不可比较的类型的字段,那么这两个结构体是不可比较的。
package main import ( "fmt" ) type image struct { data map[int]int } func main() { image1 := image{data: map[int]int{ 0: 155, }} image2 := image{data: map[int]int{ 0: 155, }} if image1 == image2 { fmt.Println("image1 and image2 are equal") } }
在上面的程序中,
image结构体类型包含了一个字段
data,该字段是
map类型。
map是不可比较的类型,因此
image1和
image2是不可比较的。如果你运行这个程序,将报错:
main.go:18: invalid operation: image1 == image2 (struct containing map[int]int cannot be compared).。
在 github 上可以找到本教程的代码。
结构体就介绍到这里。感谢阅读。
目录
上一篇:Golang教程:(十五)指针
下一篇:Golang教程:(十七)方法
相关文章推荐
- Golang教程:(十六)结构体
- Golang初级系列教程-结构体匿名字段-Anonymous fields in structs
- Golang教程:(二十六)go面向对象编程--结构体代替类
- Golang初级系列教程-结构体方法-Methods on structs
- Golang初级系列教程-常见错误
- Golang初级系列教程-内存变量指针
- Golang初级系列教程-多重继承
- Android高手进阶教程(十六)之---Android中万能的BaseAdapter(Spinner,ListView,GridView)的使用!
- C语言入门教程 (十六) 数组和指针
- Senparc.Weixin.MP SDK 微信公众平台开发教程(十六):AccessToken自动管理机制
- 轻松掌握Ajax.net系列教程十六:使用DropDownExtender
- Java语言入门教程(十六):Java语言中的接口
- 《swift2.0 官方教程中文版》 第2章-09类和结构体
- 廖雪峰Git教程笔记(十六)分支管理策略
- 轻松掌握Ajax.net系列教程十六:使用DropDownExtender
- Android游戏开发教程之十六:怎样实现图像渐变特效
- Android高手进阶教程(十六)之---Android中万能的BaseAdapter(Spinner,ListView,GridView)的使用!
- CodeRush使用教程十六:解码器(Decompiler)
- Android系列教程(十六) 在电脑上装Android
- Android简明开发教程十六:Button 画刷示例