go语言自定义type go语言函数定义

讲讲go语言的结构体

作为C语言家族的一员，go和c一样也支持结构体。可以类比于java的一个POJO。

临渭区网站制作公司哪家好，找成都创新互联公司！从网页设计、网站建设、微信开发、APP开发、响应式网站等网站项目制作，到程序开发，运营维护。成都创新互联公司于2013年开始到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选成都创新互联公司。

在学习定义结构体之前，先学习下定义一个新类型。

新类型 T1 是基于 Go 原生类型 int 定义的新自定义类型，而新类型 T2 则是 基于刚刚定义的类型 T1，定义的新类型。

这里要引入一个底层类型的概念。

如果一个新类型是基于某个 Go 原生类型定义的， 那么我们就叫 Go 原生类型为新类型的底层类型

在上面的例子中，int就是T1的底层类型。

但是T1不是T2的底层类型，只有原生类型才可以作为底层类型，所以T2的底层类型还是int

底层类型是很重要的，因为对两个变量进行显式的类型转换，只有底层类型相同的变量间才能相互转换。底层类型是判断两个类型本质上是否相同的根本。

这种类型定义方式通常用在 项目的渐进式重构，还有对已有包的二次封装方面

类型别名表示新类型和原类型完全等价，实际上就是同一种类型。只不过名字不同而已。

一般我们都是定义一个有名的结构体。

字段名的大小写决定了字段是否包外可用。只有大写的字段可以被包外引用。

还有一个点提一下

如果换行来写

Age: 66,后面这个都好不能省略

还有一个点，观察e3的赋值

new返回的是一个指针。然后指针可以直接点号赋值。这说明go默认进行了取值操作

e3.Age 等价于 (*e3).Age

如上定义了一个空的结构体Empty。打印了元素e的内存大小是0。

有什么用呢？

基于空结构体类型内存零开销这样的特性，我们在日常 Go 开发中会经常使用空 结构体类型元素，作为一种“事件”信息进行 Goroutine 之间的通信

这种以空结构体为元素类建立的 channel，是目前能实现的、内存占用最小的 Goroutine 间通信方式。

这种形式需要说的是几个语法糖。

语法糖1：

对于结构体字段，可以省略字段名，只写结构体名。默认字段名就是结构体名

这种方式称为 嵌入字段

语法糖2：

如果是以嵌入字段形式写的结构体

可以省略嵌入的Reader字段，而直接访问ReaderName

此时book是一个各个属性全是对应类型零值的一个实例。不是nil。这种情况在Go中称为零值可用。不像java会导致npe

结构体定义时可以在字段后面追加标签说明。

tag的格式为反单引号

tag的作用是可以使用[反射]来检视字段的标签信息。

具体的作用还要看使用的场景。

比如这里的tag是为了帮助 encoding/json 标准包在解析对象时可以利用的规则。比如omitempty表示该字段没有值就不打印出来。

golang中级进阶（二）：结构体

目录

一、结构体详解

1. 结构体定义

2. 实例化结构体的7种方法

二、结构体方法

1. 结构体的方法定义

2. 结构体内自定义方法的引用

3. 任意类型添加方法

三、嵌套、继承

1. 匿名结构体

2. 结构体中可以定义任意类型的字段

3. 结构体嵌套结构体

4. 结构体嵌套匿名结构体

5. 结构体嵌套多个匿名结构体

6. 结构体继承

四、结构体和JSON相互转换

1. 结构体转化成json

2. json转化成结构体

3. 结构体标签 tag

4. 嵌套结构体和json的序列化反序列化

Golang 中没有“类”的概念，Golang 中的结构体和其他语言中的类有点相似。和其他面向对 象语言中的类相比，Golang 中的结构体具有更高的扩展性和灵活性。

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

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

type 类型名 struct {

字段名 字段类型

字段名 字段类型 …

}

其中：

• 类型名：表示自定义结构体的名称，在同一个包内不能重复。

• 字段名：表示结构体字段名。结构体中的字段名必须唯一。

• 字段类型：表示结构体字段的具体类型。

在 go 语言中，没有类的概念但是可以给类型（结构体，自定义类型）定义方法。所谓方法 就是定义了接收者的函数。接收者的概念就类似于其他语言中的 this 或者 self。

方法的定义格式如下：

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

函数体

}

注意：想改变结构体内的值，必须先变成指针。

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

注意：匿名结构体中不允许出现多个重复的类型

注意：如果结构体里面有私有属性也就是小写定义的字段，则不会被json使用

golang反射自定义tag

维基百科中反射的定义：在计算机科学中，反射是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力。用比喻来说，反射就是程序在运行的时候能够“观察”并且修改自己的行为。

golang reflect包实现了反射。动态的获得程序运行时对象的结构和信息。

reflect 包中提供了两个基础的关于反射的函数来获取上述的接口和结构体：

func TypeOf(i interface{}) Type

func ValueOf(i interface{}) Value

大体上可以这样理解，TypeOf获取对象的类型信息，ValueOf获取对象中存储的值。

golang tag

golang中可以为结构体的字段添加tag。golang本身的encoding/json包解析json使用了tag，一些开源的orm框架如gorm，也使用了tag。tag可以方便的为结构体的字段添加一些信息，用reflect可以读取到，加以利用。

这是一个用tag标记列名以实现结构体自动生成xlsx的例子：

```

type Employee struct{

ID int `xlsx:”工号”`

Name string `xlsx:”姓名”`

Email string `xlsx:”邮箱”`

}

func Outputxlsx(es []*Employee) ([]byte, error) {

xt := reflect.TypeOf(es[0])

xv := reflect.ValueOf(es[0])

rows := [][]interface{}{}

headers := []interface{}{}

for i := 0; i xt.Elem().NumField(); i++ {

head, ok := xt.Elem().Field(i).Tag.Lookup("xlsx")

if ok {

headers = append(headers, head)

}

}

for _, e := range es {

cells := []interface{}{}

xv := reflect.ValueOf(e)

for i := 0; i xv.Elem().NumField(); i++ {

_, ok := xt.Elem().Field(i).Tag.Lookup("xlsx")

if ok {

cells = append(cells, xv.Elem().Field(i).Interface())

}

}

rows = append(rows, cells)

}

file := xlsx.NewFile()

sheet, _ := file.AddSheet("sheet1")

row := sheet.AddRow()

for _, header := range headers {

row.AddCell().Value = fmt.Sprintf("%v", header)

}

for _, v := range rows {

row := sheet.AddRow()

for _, vv := range v {

row.AddCell().Value = fmt.Sprintf("%v", vv)

}

}

var buffer bytes.Buffer

if err := file.Write(buffer); err != nil {

return nil, err

}

return buffer.Bytes(), nil

}

```

一学就会，手把手教你用Go语言调用智能合约

智能合约调用是实现一个 DApp 的关键，一个完整的 DApp 包括前端、后端、智能合约及区块 链系统，智能合约的调用是连接区块链与前后端的关键。

我们先来了解一下智能合约调用的基础原理。智能合约运行在以太坊节点的 EVM 中。因此要 想调用合约必须要访问某个节点。

以后端程序为例，后端服务若想连接节点有两种可能，一种是双 方在同一主机，此时后端连接节点可以采用 本地 IPC(Inter-Process Communication，进 程间通信)机制，也可以采用 RPC(Remote Procedure Call，远程过程调用)机制;另 一种情况是双方不在同一台主机，此时只能采用 RPC 机制进行通信。

提到 RPC， 读者应该对 Geth 启动参数有点印象，Geth 启动时可以选择开启 RPC 服务，对应的 默认服务端口是 8545。。

接着，我们来了解一下智能合约运行的过程。

智能合约的运行过程是后端服务连接某节点，将 智能合约的调用(交易)发送给节点，节点在验证了交易的合法性后进行全网广播，被矿工打包到 区块中代表此交易得到确认，至此交易才算完成。

就像数据库一样，每个区块链平台都会提供主流 开发语言的 SDK(Software Development Kit，软件开发工具包)，由于 Geth 本身就是用 Go 语言 编写的，因此若想使用 Go 语言连接节点、发交易，直接在工程内导入 go-ethereum(Geth 源码) 包就可以了，剩下的问题就是流程和 API 的事情了。

总结一下，智能合约被调用的两个关键点是节点和 SDK。

由于 IPC 要求后端与节点必须在同一主机，所以很多时候开发者都会采用 RPC 模式。除了 RPC，以太坊也为开发者提供了 json- rpc 接口，本文就不展开讨论了。

接下来介绍如何使用 Go 语言，借助 go-ethereum 源码库来实现智能合约的调用。这是有固定 步骤的，我们先来说一下总体步骤，以下面的合约为例。

步骤 01:编译合约，获取合约 ABI(Application Binary Interface，应用二进制接口)。 单击【ABI】按钮拷贝合约 ABI 信息，将其粘贴到文件 calldemo.abi 中(可使用 Go 语言IDE 创建该文件，文件名可自定义，后缀最好使用 abi)。

最好能将 calldemo.abi 单独保存在一个目录下，输入“ls”命令只能看到 calldemo.abi 文件，参 考效果如下:

步骤 02:获得合约地址。注意要将合约部署到 Geth 节点。因此 Environment 选择为 Web3 Provider。

在【Environment】选项框中选择“Web3 Provider”，然后单击【Deploy】按钮。

部署后，获得合约地址为:0xa09209c28AEf59a4653b905792a9a910E78E7407。

步骤 03:利用 abigen 工具(Geth 工具包内的可执行程序)编译智能合约为 Go 代码。abigen 工具的作用是将 abi 文件转换为 Go 代码，命令如下:

其中各参数的含义如下。 (1)abi:是指定传入的 abi 文件。 (2)type:是指定输出文件中的基本结构类型。 (3)pkg:指定输出文件 package 名称。 (4)out:指定输出文件名。 执行后，将在代码目录下看到 funcdemo.go 文件，读者可以打开该文件欣赏一下，注意不要修改它。

步骤 04:创建 main.go，填入如下代码。 注意代码中 HexToAddress 函数内要传入该合约部署后的地址，此地址在步骤 01 中获得。

步骤 04:设置 go mod，以便工程自动识别。

前面有所提及，若要使用 Go 语言调用智能合约，需要下载 go-ethereum 工程，可以使用下面 的指令:

该指令会自动将 go-ethereum 下载到“$GOPATH/src/github.com/ethereum/go-ethereum”，这样还算 不错。不过，Go 语言自 1.11 版本后，增加了 module 管理工程的模式。只要设置好了 go mod，下载 依赖工程的事情就不必关心了。

接下来设置 module 生效和 GOPROXY，命令如下:

在项目工程内，执行初始化，calldemo 可以自定义名称。

步骤 05:运行代码。执行代码，将看到下面的效果，以及最终输出的 2020。

上述输出信息中，可以看到 Go 语言会自动下载依赖文件，这就是 go mod 的神奇之处。看到 2020，相信读者也知道运行结果是正确的了。

没有类，C语言有结构体，那么Go的结构体有什么特别之处？

Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。

自定义类型

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

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

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

类型别名

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

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

type TypeAlias = Type

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

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

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

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

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

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

结构体的定义

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

其中：

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

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

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

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

结构体实例化

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

基本实例化

举个例子：

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

匿名结构体

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

创建指针类型结构体

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

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

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

取结构体的地址实例化

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

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

结构体初始化

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

使用键值对初始化

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

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

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

使用值的列表初始化

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

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

结构体内存布局

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

输出：

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

面试题

请问下面代码的执行结果是什么？

构造函数

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

调用构造函数

方法和接收者

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

方法的定义格式如下：

其中，

举个例子：

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

指针类型的接收者

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

调用该方法：

值类型的接收者

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

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

任意类型添加方法

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

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

结构体的匿名字段

匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。

嵌套结构体

一个结构体中可以嵌套包含另一个结构体或结构体指针。

嵌套匿名结构体

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

嵌套结构体的字段名冲突

嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义需要指定具体的内嵌结构体的字段。

结构体的“继承”

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

结构体字段的可见性

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

结构体与JSON序列化

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

结构体标签（Tag）

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

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

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

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