首页 博客列表 精选博客 智能问答 chat-GPT 关于我
Go语言基本语法 (下)
发布日期：2021-06-29 18:10:30 浏览次数：2 分类：技术文章

本文共 21603 字，大约阅读时间需要 72 分钟。

原作者博客链接：[https://www.liwenzhou.com/][https://www.liwenzhou.com/]

Golang 中文文档地址：

1. fmt 标准库介绍

fmt 包实现了类似C语言printf和scanf的格式化I/O。主要分为向外输出内容和获取输入内容两大部分。

1.1 向外输出

标准库fmt提供了以下几种输出相关函数。

1.1.1 Print

Print系列函数会将内容输出到系统的标准输出，区别在于Print函数直接输出内容，Printf函数支持格式化输出字符串，Println函数会在输出内容的结尾添加一个换行符。

func Print(a ...interface{
   }) (n int, err error)func Printf(format string, a ...interface{
   }) (n int, err error)func Println(a ...interface{
   }) (n int, err error)

举个简单的例子：

func main() {
   	fmt.Print("在终端打印该信息。")	name := "沙河小王子"	fmt.Printf("我是：%s\n", name)	fmt.Println("在终端打印单独一行显示")}

执行上面的代码输出：

在终端打印该信息。我是：沙河小王子在终端打印单独一行显示

1.1.2 Fprint

Fprint系列函数会将内容输出到一个io.Writer接口类型的变量w中，我们通常用这个函数往文件中写入内容。

func Fprint(w io.Writer, a ...interface{
   }) (n int, err error)func Fprintf(w io.Writer, format string, a ...interface{
   }) (n int, err error)func Fprintln(w io.Writer, a ...interface{
   }) (n int, err error)

举个例子：

// 向标准输出写入内容fmt.Fprintln(os.Stdout, "向标准输出写入内容")fileObj, err := os.OpenFile("./xx.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)if err != nil {
   	fmt.Println("打开文件出错，err:", err)	return}name := "沙河小王子"// 向打开的文件句柄中写入内容fmt.Fprintf(fileObj, "往文件中写如信息：%s", name)

注意，只要满足io.Writer接口的类型都支持写入。

1.1.3 Sprint

Sprint系列函数会把传入的数据生成并返回一个字符串。

func Sprint(a ...interface{
   }) stringfunc Sprintf(format string, a ...interface{
   }) stringfunc Sprintln(a ...interface{
   }) string

简单的示例代码如下：

s1 := fmt.Sprint("沙河小王子")name := "沙河小王子"age := 18s2 := fmt.Sprintf("name:%s,age:%d", name, age)fmt.Println(s2)s3 := fmt.Sprintln("沙河小王子")fmt.Println(s1, s2, s3)

1.1.4 Errorf

Errorf函数根据format参数生成格式化字符串并返回一个包含该字符串的错误。

func Errorf(format string, a ...interface{
   }) error

通常使用这种方式来自定义错误类型，例如：

err := fmt.Errorf("这是一个错误")

Go1.13版本为fmt.Errorf函数新加了一个%w占位符用来生成一个可以包裹Error的Wrapping Error。

e := errors.New("原始错误e")w := fmt.Errorf("Wrap了一个错误%w", e)

1.2 格式化占位符

*printf系列函数都支持format格式化参数，在这里我们按照占位符将被替换的变量类型划分，方便查询和记忆。

1.2.1 通用占位符

占位符 说明
%v 值的默认格式表示
%+v 类似%v，但输出结构体时会添加字段名
%#v 值的Go语法表示
%T 打印值的类型
%% 百分号

示例代码如下：

fmt.Printf("%v\n", 100)fmt.Printf("%v\n", false)o := struct{
    name string }{
   "小王子"}fmt.Printf("%v\n", o)fmt.Printf("%#v\n", o)fmt.Printf("%T\n", o)fmt.Printf("100%%\n")

输出结果如下：

100false{
   小王子}struct {
    name string }{
   name:"小王子"}struct {
    name string }100%

1.2.2 布尔型

占位符 说明
%t true或false

1.2.3 整型

占位符 说明
%b 表示为二进制
%c 该值对应的unicode码值
%d 表示为十进制
%o 表示为八进制
%x 表示为十六进制，使用a-f
%X 表示为十六进制，使用A-F
%U 表示为Unicode格式：U+1234，等价于”U+%04X”
%q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示

示例代码如下：

n := 65fmt.Printf("%b\n", n)fmt.Printf("%c\n", n)fmt.Printf("%d\n", n)fmt.Printf("%o\n", n)fmt.Printf("%x\n", n)fmt.Printf("%X\n", n)

输出结果如下：

1000001A651014141

1.2.4 浮点数与复数

占位符 说明
%b 无小数部分、二进制指数的科学计数法，如-123456p-78
%e 科学计数法，如-1234.456e+78
%E 科学计数法，如-1234.456E+78
%f 有小数部分但无指数部分，如123.456
%F 等价于%f
%g 根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
%G 根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

示例代码如下：

f := 12.34fmt.Printf("%b\n", f)fmt.Printf("%e\n", f)fmt.Printf("%E\n", f)fmt.Printf("%f\n", f)fmt.Printf("%g\n", f)fmt.Printf("%G\n", f)

输出结果如下：

6946802425218990p-491.234000e+011.234000E+0112.34000012.3412.34

1.2.5 字符串和[]byte

占位符 说明
%s 直接输出字符串或者[]byte
%q 该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%x 每个字节用两字符十六进制数表示（使用a-f
%X 每个字节用两字符十六进制数表示（使用A-F）

示例代码如下：

s := "小王子"fmt.Printf("%s\n", s)fmt.Printf("%q\n", s)fmt.Printf("%x\n", s)fmt.Printf("%X\n", s)

输出结果如下：

小王子"小王子"e5b08fe78e8be5ad90E5B08FE78E8BE5AD90

1.2.6 指针

占位符 说明
%p 表示为十六进制，并加上前导的0x

示例代码如下：

a := 10fmt.Printf("%p\n", &a)fmt.Printf("%#p\n", &a)

输出结果如下：

0xc000094000c000094000

1.2.7 宽度标识符

宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下：

占位符 说明
%f 默认宽度，默认精度
%9f 宽度9，默认精度
%.2f 默认宽度，精度2
%9.2f 宽度9，精度2
%9.f 宽度9，精度0

示例代码如下：

n := 12.34fmt.Printf("%f\n", n)fmt.Printf("%9f\n", n)fmt.Printf("%.2f\n", n)fmt.Printf("%9.2f\n", n)fmt.Printf("%9.f\n", n)

输出结果如下：

12.34000012.34000012.34    12.34       12

1.2.8 其他falg

占位符 说明
’+’ 总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）；
’ ‘ 对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格
’-’ 在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）；
’#’ 八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）对%q（%#q），对%U（%#U）会输出空格和单引号括起来的go字面值；
‘0’ 使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面；

举个例子：

s := "小王子"fmt.Printf("%s\n", s)fmt.Printf("%5s\n", s)fmt.Printf("%-5s\n", s)fmt.Printf("%5.7s\n", s)fmt.Printf("%-5.7s\n", s)fmt.Printf("%5.2s\n", s)fmt.Printf("%05s\n", s)

输出结果如下：

小王子  小王子小王子    小王子小王子     小王00小王子

1.3 获取输入

Go语言fmt包下有fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，可以在程序运行过程中从标准输入获取用户的输入。

1.3.1 fmt.Scan

函数定签名如下：

func Scan(a ...interface{
   }) (n int, err error)
  • Scan从标准输入扫描文本，读取由空白符分隔的值保存到传递给本函数的参数中，换行符视为空白符。
  • 本函数返回成功扫描的数据个数和遇到的任何错误。如果读取的数据个数比提供的参数少，会返回一个错误报告原因。

具体代码示例如下：

func main() {
   	var (		name    string		age     int		married bool	)	fmt.Scan(&name, &age, &married)	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)}

将上面的代码编译后在终端执行，在终端依次输入小王子、28和false使用空格分隔。

$ ./scan_demo 小王子 28 false扫描结果 name:小王子 age:28 married:false

fmt.Scan从标准输入中扫描用户输入的数据，将以空白符分隔的数据分别存入指定的参数。

1.3.2 fmt.Scanf

函数签名如下：

func Scanf(format string, a ...interface{
   }) (n int, err error)
  • Scanf从标准输入扫描文本，根据format参数指定的格式去读取由空白符分隔的值保存到传递给本函数的参数中。
  • 本函数返回成功扫描的数据个数和遇到的任何错误。

代码示例如下：

func main() {
   	var (		name    string		age     int		married bool	)	fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married)	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)}

将上面的代码编译后在终端执行，在终端按照指定的格式依次输入小王子、28和false。

$ ./scan_demo 1:小王子 2:28 3:false扫描结果 name:小王子 age:28 married:false

fmt.Scanf不同于fmt.Scan简单的以空格作为输入数据的分隔符，fmt.Scanf为输入数据指定了具体的输入内容格式，只有按照格式输入数据才会被扫描并存入对应变量。

例如，我们还是按照上个示例中以空格分隔的方式输入，fmt.Scanf就不能正确扫描到输入的数据。

$ ./scan_demo 小王子 28 false扫描结果 name: age:0 married:false

1.3.3 fmt.Scanln

函数签名如下：

func Scanln(a ...interface{
   }) (n int, err error)
  • Scanln类似Scan，它在遇到换行时才停止扫描。最后一个数据后面必须有换行或者到达结束位置。
  • 本函数返回成功扫描的数据个数和遇到的任何错误。

具体代码示例如下：

func main() {
   	var (		name    string		age     int		married bool	)	fmt.Scanln(&name, &age, &married)	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)}

将上面的代码编译后在终端执行，在终端依次输入小王子、28和false使用空格分隔。

$ ./scan_demo 小王子 28 false扫描结果 name:小王子 age:28 married:false

fmt.Scanln遇到回车就结束扫描了，这个比较常用。

1.3.4 bufio.NewReader

有时候我们想完整获取输入的内容，而输入的内容可能包含空格，这种情况下可以使用bufio包来实现。示例代码如下：

func bufioDemo() {
   	reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象	fmt.Print("请输入内容：")	text, _ := reader.ReadString('\n') // 读到换行	text = strings.TrimSpace(text)	fmt.Printf("%#v\n", text)}

1.3.5 Fscan系列

这几个函数功能分别类似于fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，只不过它们不是从标准输入中读取数据而是从io.Reader中读取数据。

func Fscan(r io.Reader, a ...interface{
   }) (n int, err error)func Fscanln(r io.Reader, a ...interface{
   }) (n int, err error)func Fscanf(r io.Reader, format string, a ...interface{
   }) (n int, err error)

1.3.6 Sscan系列

这几个函数功能分别类似于fmt.Scan、fmt.Scanf、fmt.Scanln三个函数，只不过它们不是从标准输入中读取数据而是从指定字符串中读取数据。

func Sscan(str string, a ...interface{
   }) (n int, err error)func Sscanln(str string, a ...interface{
   }) (n int, err error)func Sscanf(str string, format string, a ...interface{
   }) (n int, err error)

2. time 包

time包提供了时间的显示和测量用的函数。日历的计算采用的是公历。

2.1 时间类型

time.Time类型表示时间。我们可以通过time.Now()函数获取当前的时间对象，然后获取时间对象的年月日时分秒等信息。示例代码如下：

func timeDemo() {
   	now := time.Now() //获取当前时间	fmt.Printf("current time:%v\n", now)	year := now.Year()     //年	month := now.Month()   //月	day := now.Day()       //日	hour := now.Hour()     //小时	minute := now.Minute() //分钟	second := now.Second() //秒	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)}

2.2 时间戳

时间戳是自1970年1月1日（08:00:00GMT）至当前时间的总毫秒数。它也被称为Unix时间戳（UnixTimestamp）。

基于时间对象获取时间戳的示例代码如下：

func timestampDemo() {
   	now := time.Now()            //获取当前时间	timestamp1 := now.Unix()     //时间戳	timestamp2 := now.UnixNano() //纳秒时间戳	fmt.Printf("current timestamp1:%v\n", timestamp1)	fmt.Printf("current timestamp2:%v\n", timestamp2)}

使用time.Unix()函数可以将时间戳转为时间格式。

func timestampDemo2(timestamp int64) {
   	timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式	fmt.Println(timeObj)	year := timeObj.Year()     //年	month := timeObj.Month()   //月	day := timeObj.Day()       //日	hour := timeObj.Hour()     //小时	minute := timeObj.Minute() //分钟	second := timeObj.Second() //秒	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)}

2.3 时间间隔

time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration表示一段时间间隔，可表示的最长时间段大约290年。

time包中定义的时间间隔类型的常量如下：

const (    Nanosecond  Duration = 1    Microsecond          = 1000 * Nanosecond    Millisecond          = 1000 * Microsecond    Second               = 1000 * Millisecond    Minute               = 60 * Second    Hour                 = 60 * Minute)

例如：time.Duration表示1纳秒，time.Second表示1秒。

2.4 时间操作

2.4.1 Add

我们在日常的编码过程中可能会遇到要求时间+时间间隔的需求，Go语言的时间对象有提供Add方法如下：

func (t Time) Add(d Duration) Time

举个例子，求一个小时之后的时间：

func main() {
   	now := time.Now()	later := now.Add(time.Hour) // 当前时间加1小时后的时间	fmt.Println(later)}

2.4.2 Sub

求两个时间之间的差值：

func (t Time) Sub(u Time) Duration

返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。要获取时间点t-d（d为Duration），可以使用t.Add(-d)。

2.4.3 Equal

func (t Time) Equal(u Time) bool

判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。本方法和用t==u不同，这种方法还会比较地点和时区信息。

2.4.4 Before

func (t Time) Before(u Time) bool

如果t代表的时间点在u之前，返回真；否则返回假。

2.4.5 After

func (t Time) After(u Time) bool

如果t代表的时间点在u之后，返回真；否则返回假。

2.5 定时器

使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道（channel）。

func tickDemo() {
   	ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器	for i := range ticker {
   		fmt.Println(i)//每秒都会执行的任务	}}

2.6 时间格式化

时间类型有一个自带的方法Format进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4）。也许这就是技术人员的浪漫吧。

补充：如果想格式化为12小时方式，需指定PM。

func formatDemo() {
   	now := time.Now()	// 格式化的模板为Go的出生时间2006年1月2号15点04分 Mon Jan	// 24小时制	fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))	// 12小时制	fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))	fmt.Println(now.Format("2006/01/02 15:04"))	fmt.Println(now.Format("15:04 2006/01/02"))	fmt.Println(now.Format("2006/01/02"))}

2.6.1 解析字符串格式的时间

now := time.Now()fmt.Println(now)// 加载时区loc, err := time.LoadLocation("Asia/Shanghai")if err != nil {
   	fmt.Println(err)	return}// 按照指定时区和指定格式解析字符串时间timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2019/08/04 14:15:20", loc)if err != nil {
   	fmt.Println(err)	return}fmt.Println(timeObj)fmt.Println(timeObj.Sub(now))

3. Go 语言中的结构体

3.1 类型别名和自定义类型

3.1.1 自定义类型

在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型， Go语言中可以使用type关键字来定义自定义类型。

自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。例如：

//将MyInt定义为int类型type MyInt int

通过type关键字的定义，MyInt就是一种新的类型，它具有int的特性。

3.1.2 类型别名

类型别名是Go1.9版本添加的新功能。

类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。就像一个孩子小时候有小名、乳名，上学后用学名，英语老师又会给他起英文名，但这些名字都指的是他本人。

type TypeAlias = Type

我们之前见过的rune和byte就是类型别名，他们的定义如下：

type byte = uint8type rune = int32

3.1.3 类型定义和类型别名的区别

类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别。

//类型定义type NewInt int//类型别名type MyInt = intfunc main() {
   	var a NewInt	var b MyInt		fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt	fmt.Printf("type of b:%T\n", b) //type of b:int}

结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型。b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。

3.2 结构体

Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了，Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct。 也就是我们可以通过struct来定义自己的类型了。

Go语言中通过struct来实现面向对象。

3.2.1 结构体的定义

使用type和struct关键字来定义结构体，具体代码格式如下：

type 类型名 struct {
       字段名 字段类型    字段名 字段类型    …}

其中：

  • 类型名：标识自定义结构体的名称，在同一个包内不能重复。
  • 字段名：表示结构体字段名。结构体中的字段名必须唯一。
  • 字段类型：表示结构体字段的具体类型。

举个例子，我们定义一个Person（人）结构体，代码如下：

type person struct {
   	name string	city string	age  int8}

同样类型的字段也可以写在一行，

type person1 struct {
   	name, city string	age        int8}

这样我们就拥有了一个person的自定义类型，它有name、city、age三个字段，分别表示姓名、城市和年龄。这样我们使用这个person结构体就能够很方便的在程序中表示和存储人信息了。

语言内置的基础数据类型是用来描述一个值的，而结构体是用来描述一组值的。比如一个人有名字、年龄和居住城市等，本质上是一种聚合型的数据类型

3.2.2 结构体实例化

只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。

结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型。

var 结构体实例 结构体类型

3.2.3 基本实例化

举个例子：

type person struct {
   	name string	city string	age  int8}func main() {
   	var p1 person	p1.name = "沙河娜扎"	p1.city = "北京"	p1.age = 18	fmt.Printf("p1=%v\n", p1)  //p1={沙河娜扎 北京 18}	fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"沙河娜扎", city:"北京", age:18}}

我们通过.来访问结构体的字段（成员变量）,例如p1.name和p1.age等。

3.2.4 匿名结构体

在定义一些临时数据结构等场景下还可以使用匿名结构体。

package main     import (    "fmt")     func main() {
       var user struct{
   Name string; Age int}    user.Name = "小王子"    user.Age = 18    fmt.Printf("%#v\n", user)}

3.2.5 创建指针类型结构体

我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址。 格式如下：

var p2 = new(person)fmt.Printf("%T\n", p2)     //*main.personfmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

从打印的结果中我们可以看出p2是一个结构体指针。

需要注意的是在Go语言中支持对结构体指针直接使用.来访问结构体的成员。

var p2 = new(person)p2.name = "小王子"p2.age = 28p2.city = "上海"fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"小王子", city:"上海", age:28}

3.2.6 取结构体的地址实例化

使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。

p3 := &person{
   }fmt.Printf("%T\n", p3)     //*main.personfmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}p3.name = "七米"p3.age = 30p3.city = "成都"fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"七米", city:"成都", age:30}

p3.name = "七米"其实在底层是(*p3).name = "七米"，这是Go语言帮我们实现的语法糖。

3.2.7 结构体初始化

没有初始化的结构体，其成员变量都是对应其类型的零值。

type person struct {
   	name string	city string	age  int8}func main() {
   	var p4 person	fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"", city:"", age:0}}

3.2.8 使用键值对初始化

使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值。

p5 := person{
   	name: "小王子",	city: "北京",	age:  18,}fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"小王子", city:"北京", age:18}

也可以对结构体指针进行键值对初始化，例如：

p6 := &person{
   	name: "小王子",	city: "北京",	age:  18,}fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"小王子", city:"北京", age:18}

当某些字段没有初始值的时候，该字段可以不写。此时，没有指定初始值的字段的值就是该字段类型的零值。

p7 := &person{
   	city: "北京",}fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}

3.2.9 使用值的列表初始化

初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：

p8 := &person{
   	"沙河娜扎",	"北京",	28,}fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"沙河娜扎", city:"北京", age:28}

使用这种格式初始化时，需要注意：

  1. 必须初始化结构体的所有字段。
  2. 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
  3. 该方式不能和键值初始化方式混用。

3.3 结构体内存布局

结构体占用一块连续的内存。

type test struct {
   	a int8	b int8	c int8	d int8}n := test{
   	1, 2, 3, 4,}fmt.Printf("n.a %p\n", &n.a)fmt.Printf("n.b %p\n", &n.b)fmt.Printf("n.c %p\n", &n.c)fmt.Printf("n.d %p\n", &n.d)

输出：

n.a 0xc0000a0060n.b 0xc0000a0061n.c 0xc0000a0062n.d 0xc0000a0063

【进阶知识点】关于Go语言中的内存对齐推荐阅读:

3.3.1 空结构体

空结构体是不占用空间的。

var v struct{
   }fmt.Println(unsafe.Sizeof(v))  // 0

3.4 构造函数

Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。

func newPerson(name, city string, age int8) *person {
   	return &person{
   		name: name,		city: city,		age:  age,	}}

调用构造函数

p9 := newPerson("张三", "沙河", 90)fmt.Printf("%#v\n", p9) //&main.person{name:"张三", city:"沙河", age:90}

3.5 方法和接收者

Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。

方法的定义格式如下：

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
       函数体}

其中，

  • 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名称首字母的小写，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
  • 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
  • 方法名、参数列表、返回参数：具体格式与函数定义相同。

举个例子：

//Person 结构体type Person struct {
   	name string	age  int8}//NewPerson 构造函数func NewPerson(name string, age int8) *Person {
   	return &Person{
   		name: name,		age:  age,	}}//Dream Person做梦的方法func (p Person) Dream() {
   	fmt.Printf("%s的梦想是学好Go语言！\n", p.name)}func main() {
   	p1 := NewPerson("小王子", 25)	p1.Dream()}

方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。

3.5.1 指针类型的接收者

指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的this或者self。 例如我们为Person添加一个SetAge方法，来修改实例变量的年龄。

// SetAge 设置p的年龄// 使用指针接收者func (p *Person) SetAge(newAge int8) {
   	p.age = newAge}

调用该方法：

func main() {
   	p1 := NewPerson("小王子", 25)	fmt.Println(p1.age) // 25	p1.SetAge(30)	fmt.Println(p1.age) // 30}

3.5.2 值类型的接收者

当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。

// SetAge2 设置p的年龄// 使用值接收者func (p Person) SetAge2(newAge int8) {
   	p.age = newAge}func main() {
   	p1 := NewPerson("小王子", 25)	p1.Dream()	fmt.Println(p1.age) // 25	p1.SetAge2(30) // (*p1).SetAge2(30)	fmt.Println(p1.age) // 25}

3.5.3 什么时候应该使用指针类型接收者

  1. 需要修改接收者中的值
  2. 接收者是拷贝代价比较大的大对象
  3. 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。

3.6 任意类型添加方法

在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。

//MyInt 将int定义为自定义MyInt类型type MyInt int//SayHello 为MyInt添加一个SayHello的方法func (m MyInt) SayHello() {
   	fmt.Println("Hello, 我是一个int。")}func main() {
   	var m1 MyInt	m1.SayHello() //Hello, 我是一个int。	m1 = 100	fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt}

注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。

3.7 结构体的匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。

//Person 结构体Person类型type Person struct {
   	string	int}func main() {
   	p1 := Person{
   		"小王子",		18,	}	fmt.Printf("%#v\n", p1)        //main.Person{string:"北京", int:18}	fmt.Println(p1.string, p1.int) //北京 18}

**注意：**这里匿名字段的说法并不代表没有字段名，而是默认会采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。

3.8 嵌套结构体

一个结构体中可以嵌套包含另一个结构体或结构体指针，就像下面的示例代码那样。

//Address 地址结构体type Address struct {
   	Province string	City     string}//User 用户结构体type User struct {
   	Name    string	Gender  string	Address Address}func main() {
   	user1 := User{
   		Name:   "小王子",		Gender: "男",		Address: Address{
   			Province: "山东",			City:     "威海",		},	}	fmt.Printf("user1=%#v\n", user1)//user1=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山东", City:"威海"}}}

3.8.1 嵌套匿名字段

上面user结构体中嵌套的Address结构体也可以采用匿名字段的方式，例如：

//Address 地址结构体type Address struct {
   	Province string	City     string}//User 用户结构体type User struct {
   	Name    string	Gender  string	Address //匿名字段}func main() {
   	var user2 User	user2.Name = "小王子"	user2.Gender = "男"	user2.Address.Province = "山东"    // 匿名字段默认使用类型名作为字段名	user2.City = "威海"                // 匿名字段可以省略	fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山东", City:"威海"}}}

当访问结构体成员时会先在结构体中查找该字段，找不到再去嵌套的匿名字段中查找。

3.8.2 嵌套结构体的字段名冲突

嵌套结构体内部可能存在相同的字段名。在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。

//Address 地址结构体type Address struct {
   	Province   string	City       string	CreateTime string}//Email 邮箱结构体type Email struct {
   	Account    string	CreateTime string}//User 用户结构体type User struct {
   	Name   string	Gender string	Address	Email}func main() {
   	var user3 User	user3.Name = "沙河娜扎"	user3.Gender = "男"	// user3.CreateTime = "2019" //ambiguous selector user3.CreateTime	user3.Address.CreateTime = "2000" //指定Address结构体中的CreateTime	user3.Email.CreateTime = "2000"   //指定Email结构体中的CreateTime}

3.9 结构体的“继承”

Go语言中使用结构体也可以实现其他编程语言中面向对象的继承。

//Animal 动物type Animal struct {
   	name string}func (a *Animal) move() {
   	fmt.Printf("%s会动！\n", a.name)}//Dog 狗type Dog struct {
   	Feet    int8	*Animal //通过嵌套匿名结构体实现继承}func (d *Dog) wang() {
   	fmt.Printf("%s会汪汪汪~\n", d.name)}func main() {
   	d1 := &Dog{
   		Feet: 4,		Animal: &Animal{
    //注意嵌套的是结构体指针			name: "乐乐",		},	}	d1.wang() //乐乐会汪汪汪~	d1.move() //乐乐会动！}

3.10 结构体字段的可见性

结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。

3.11 结构体与JSON序列化

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔。

//Student 学生type Student struct {
   	ID     int	Gender string	Name   string}//Class 班级type Class struct {
   	Title    string	Students []*Student}func main() {
   	c := &Class{
   		Title:    "101",		Students: make([]*Student, 0, 200),	}	for i := 0; i < 10; i++ {
   		stu := &Student{
   			Name:   fmt.Sprintf("stu%02d", i),			Gender: "男",			ID:     i,		}		c.Students = append(c.Students, stu)	}	//JSON序列化：结构体-->JSON格式的字符串	data, err := json.Marshal(c)	if err != nil {
   		fmt.Println("json marshal failed")		return	}	fmt.Printf("json:%s\n", data)	//JSON反序列化：JSON格式的字符串-->结构体	str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`	c1 := &Class{
   }	err = json.Unmarshal([]byte(str), c1)	if err != nil {
   		fmt.Println("json unmarshal failed!")		return	}	fmt.Printf("%#v\n", c1)}

3.12 结构体标签（Tag）

Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。 Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：

`key1:"value1" key2:"value2"`

结构体tag由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。

注意事项： 为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。

例如我们为Student结构体的每个字段定义json序列化时使用的Tag：

//Student 学生type Student struct {
   	ID     int    `json:"id"` //通过指定tag实现json序列化该字段时的key	Gender string //json序列化是默认使用字段名作为key	name   string //私有不能被json包访问}func main() {
   	s1 := Student{
   		ID:     1,		Gender: "男",		name:   "沙河娜扎",	}	data, err := json.Marshal(s1)	if err != nil {
   		fmt.Println("json marshal failed!")		return	}	fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}}

3.13 结构体和方法补充知识点

因为slice和map这两种数据类型都包含了指向底层数据的指针，因此我们在需要复制它们时要特别注意。我们来看下面的例子：

type Person struct {
   	name   string	age    int8	dreams []string}func (p *Person) SetDreams(dreams []string) {
   	p.dreams = dreams}func main() {
   	p1 := Person{
   name: "小王子", age: 18}	data := []string{
   "吃饭", "睡觉", "打豆豆"}	p1.SetDreams(data)	// 你真的想要修改 p1.dreams 吗？	data[1] = "不睡觉"	fmt.Println(p1.dreams)  // ?}

正确的做法是在方法中使用传入的slice的拷贝进行结构体赋值。

func (p *Person) SetDreams(dreams []string) {
   	p.dreams = make([]string, len(dreams))	copy(p.dreams, dreams)}

同样的问题也存在于返回值slice和map的情况，在实际编码过程中一定要注意这个问题。

转载地址：https://csp1999.blog.csdn.net/article/details/110679829 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！

上一篇：wkhtmltopdf工具将网站转换成pdf或图片
下一篇：Go语言基本语法 (中)

发表评论

最新留言

哈哈，博客排版真的漂亮呢~
[***.90.31.176]2024年04月28日 21时10分59秒

关于作者

    喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！
-- 愿君每日到此一游！

推荐文章

运维面试基础试题（四） 2019-04-29
一键安装Openstack单节点 必能成功 2019-04-29
面试紧张怎么办 2019-04-29
关系型数据库 ，nosql数据库简介 2019-04-29
Centos 7搭建NTP时间同步服务器 2019-04-29
centos7 基于rsync+inotify 实现定时备份 2019-04-29
指定IP进行 文件的分发 2019-04-29
基于http搭建本地yum仓库 2019-04-29
常规邮件基础 2019-04-29
邮件基础之 -- SMTP协议 2019-04-29
Java设计模式--责任链模式 2019-04-29
OpenCV的cvLoadImage函数 2019-04-29
OpenCV中与matlab中相对应的函数 2019-04-29
C/C++中二维数组作函数形参时，调用函数时，可传递的实参类型的小结 2019-04-29
cvGetSubRect与cvMul用法 2019-04-29
opencv图像处理梯度边缘和角点 2019-04-29
Caffe源码中blob文件分析 2019-04-29
OpenCV 图像采样 插值 几何变换 2019-04-29
图像处理-仿射变换 AffineTransform 2019-04-29
图像二值化----otsu（最大类间方差法、大津算法） 2019-04-29
白红宇的个人博客 - 记录点点滴滴的事 - 您是第 310175076 位访客
访问时间: 2024-05-02 23:49:23 访问IP: 18.191.157.186     Copyright © 2020 - 2023 blog.css8.cn 京ICP备2021015314号-1 手机版