Golang学习（19）：结构体的方法

## 结构体

`struct` 是用户定义的类型，其中包含命名字段的集合。
可以将他看做支持组合，但不支持集成的 `class`





### 定义结构体

```go
// type 表示引入一个新类型，struct 表示定义的是一个 结构体
// 定义一个 Person
type Person struct {
    // 定义一些字段
    Hobby string
    
    // 同类型可以合并定义
    FirstName LastName string
    
    Age int
}
```

### 声明结构体

我们可以像其他数据类型一样声明它

```go
type Person struct {
    // 定义一些字段
    Hobby string
    // 同类型可以合并定义
    FirstName, LastName string

    Age int
}

func main() {
    var p1 Person

    fmt.Println("Person 1:", p1)
}
```

![image.png](https://oss.silon.vip/img/9588e5735f6124e062b34eccbc6776bc.image.png)

正如我们所看到的，所有结构字段都用它们的零值初始化。
所以FirstNameandLastName被设置为空字符串，并且Age被设置为 0。

### 初始化结构体

```go
func main() {
    var p1 = Person{
        Hobby: "Piano",
        FirstName: "AA",
        LastName: "BB",
        Age: 22,
    }

    fmt.Println("Person 1:", p1)
}
```


![image.png](https://oss.silon.vip/img/9d6492f75ca410d7397380cedc5f67ef.image.png)


:::info{title="相关信息"}
结构体也支持没有字段名的初始化

- 如果不填写字段名，就必须全不填写
- 不填写字段名，就必须提供所有的值
:::

```go

func main() {
    var p1 = Person{
        "Piano",
        "AA",
        "BB",
        22,
    }

    fmt.Println("Person 1:", p1)
}
```

### 声明匿名结构体

```go
func main() {
    var a = struct {
	Name string
    }{"Golang"}

    fmt.Println("Anonymous:", a)
}
```


![image.png](https://oss.silon.vip/img/2050300d10dac7ed6a667f95bae3ade3.image.png)


### 访问字段

```go
func main() {
    var p1 = Person{
        "Piano",
        "AA",
        "BB",
        22,
    }

    // 访问 p1 的 age
    fmt.Println(p1.age)
}
```

我们也可以使用内置`new`函数

```go
func main() {
    p := new(Person)

    p.FirstName = "AA"
    p.LastName = "BB"
    p.Age = 22

    // new 的结果是一个指针的值
    // &{  AA BB 22}
    fmt.Println(p)
    
    // AA
    fmt.Println(p.FirstName)
}
```


:::warning{title="注意"}
两个结构的所有对应字段也相等，则它们是相等的

```go
func main() {
    var p1 = Person{"a", "b", 20}
    var p2 = Person{"a", "b", 20}

    // true
    fmt.Println(p1 == p2)
}
```
:::

### 导出字段

变量和函数的规则相同
如果使用小写标识符声明结构字段，它将不会被导出，并且仅对定义它的包可见

```go
// 会被到处
type Person struct {
    FirstName, LastName  string
    Age                  int
    // 不会被导出
     hobby              string
}

// 不会被导出
type person struct {
    FirstName, LastName  string
    Age                  int
    zipCode              string
}
```


### 嵌套结构体

```go
type Person struct {
    FirstName, LastName  string
    Age                  int
}

// 新结构体将具有原始结构的所有属性
type SuperHero struct {
    // 在 Person 的基础拓展
    Person
    Alias string
}

func main() {
    s := SuperHero{}

    s.FirstName = "AA"
    s.LastName = "BB"
    s.Age = 22
    s.Alias = "CC"

    // {{AA BB 22} CC}
    fmt.Println(s)
}
```

** 然而，这通常不被推荐，并且在大多数情况下，优先使用组合组合**

### 组合结构体

```go
type Person struct {
    FirstName, LastName  string
    Age                  int
}

type SuperHero struct {
    //  定义了一个值，类型是 Person
    Person Person
    Alias string
}

func main() {
    p := Person{"Bruce", "Wayne", 40}
    s := SuperHero{p, "batman"}

    fmt.Println(s)

    // 效果相同，但是更容易管理和控制
    // {{AA BB 22} CC}
    fmt.Println(s)
}
```

### 结构体标签



:::danger{title="警告"}
????????????这里还没有太理解
:::
结构体标签是对结构体字段的额外信息标签。


:::info{title="相关信息"}
JSON、BSON 等格式进行序列化及对象关系映射（Object Relational Mapping，简称 ORM）系统都会用到结构体标签，这些系统使用标签设定字段在处理时应该具备的特殊属性和可能发生的行为。这些信息都是静态的，无须实例化结构体，可以通过反射（reflect）获取到。
:::


```go
// Tag 在结构体字段后方书写的格式如下：
`key1:"value1" key2:"value2"`
```

结构体标签由一个或多个键值对组成。
键与值使用冒号分隔，值用双引号括起来。键值对之间使用一个空格分隔。

```go
type cat struct {
    Name string
    Type int    `json:"type" id:"100"`
}

type Animal struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}
```

#### 结构体的存储特性

结构体是一种值的类型

当我们将 `struct` 传递给另变量时，该函数会生成 自己独立的 `struct`存储

```go
package main

import "fmt"

type Point struct {
	X, Y float64
}

func main() {
	p1 := Point{1, 2}
	p2 := p1 // Copy of p1 is assigned to p2

	p2.X = 2

	fmt.Println(p1) // Output: {1 2}
	fmt.Println(p2) // Output: {2 2}
}
```

**空结构体占用零字节的存储空间**

```go
package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var s struct{}
	fmt.Println(unsafe.Sizeof(s)) // Output: 0
}
```

Golang学习（18）：结构体

## 构建程序

go build 可以很容易地做到程序的构建


![image.png](https://oss.silon.vip/img/1ffd770fbf69d48189c3ce6a5dbb7060.image.png)


go build 可以生成一个静态二进制文件




我们还可以指定输出。

```bash
go build -o app
```


![image.png](https://oss.silon.vip/img/c8e5fd406240f6b34906b2b5d8607c7a.image.png)


## 运行构建结果

运行结果只需要调用文件即可


![image.png](https://oss.silon.vip/img/b1735bd8edce8f326c6f7625c129aef0.image.png)


## 平台兼容

构建时要注意两个构建变量
- `GOOS`
- `GOARCH`

我们可以通过 `go tool` 命令列出所有支持的架构

```bash
go tool dist list
```

![image.png](https://oss.silon.vip/img/899df380d6872f254381b5539f0ae13f.image.png)

这下，就可以增加两个构建变量，来构建特定平台的应用

```bash
// 从 macOS 构建 windows 可执行文件
GOOS=windows GOARCH=amd64 go build -o app.exe
```


![image.png](https://oss.silon.vip/img/3fd3f6e63e6fe16ce95af6b4d183ae2c.image.png)

## 打包依赖

`CGO_ENABLED`变量允许我们配置CGO，这是 Go 中调用 C 代码的一种方式

这有助于我们生成一个静态链接的二进制文件，它可以在没有任何外部依赖的情况下工作

```bash
CGO_ENABLED=0 go build -o app
```

Golang学习（17）：构建、打包程序

## go sdk 命令行工具

Go SDK 提供了丰富且实用的命令行工具，涵盖编译、代码格式化、源码获取、测试和性能分析等方方面面





### go build
go build 命令的作用是编译 Go 源码，并生成可执行的文件。

:::info{title="相关信息"}
在编译过程中，除了我们自己写的代码外，如果使用了第三方的包，这些包会被一同编译。当我们执行 go build 命令后，会搜索当前目录下的 go 源码并完成编译。
:::

go build 命令还允许附加参数


![image.png](https://oss.silon.vip/img/371e78ac59b2726db919d5a88a217a77.image.png)



![image.png](https://oss.silon.vip/img/4b43847a1ce51ee92a31debcce8f02c0.image.png)


### go install

go install 命令的作用和 go build 类似，都是将源码编译为可执行的文件，附加参数也基本通用

区别在于：

- go install 命令生成的可执行文件使用包名来命名；
- go install 命令在编译源码后，会将可执行文件或库文件安装到约定的目录下；
- 默认情况下，go install 命令会将可执行文件安装到 GOPATH\bin 目录下，依赖的三方包会被安装到 GOPATH\bin 目录下。

### go get

go get 命令的作用是获取源码包，这一操作包含两个步骤
1. 下载源码
2. 执行 go install 命令进行安装


:::info{title="go 的包索引库"}
[pkg.go.dev/](pkg.go.dev/)

搜索包名，在包详情页可以找到仓库地址
:::

```bash
// 下载 go 包
// go get <包仓库地址>
go get github.com/ethereum/go-ethereum

// 若要指定所获取源码包的版本，可以通过添加 “@版本号” 的方式执行
go get github.com/ethereum/go-ethereum@v1.10.1
```

go get 命令还允许附加参数

![image.png](https://oss.silon.vip/img/67f18ff853ed19b4b7a63e1cbc9e669f.image.png)

### go clean

go clean 命令可以清理当前目录内的所有编译生成的文件


包括：

- 当前目录下生成的与包名或者 Go 源码文件同名的可执行文件
- 当前目录中 _obj 和 _test 目录中名为 `_testmain.go、test.out、build.out、a.out 以及后缀为 .5、.6、.8、.a、.o和 .so `的文件，这些文件通常是执行go build命令后生成的；
- 当前目录下生成的包名加 “.test” 后缀为名的文件，这些文件通常是执行 go test 命令后生成的；
- 工作区中 pkg 和 bin 目录的相应归档文件和可执行文件，这些文件通常是执行 go install 命令后生成的。

go clean 命令还允许附加参数


![image.png](https://oss.silon.vip/img/70059550711b430e53eee18499e0ede8.image.png)


:::info{title="提示"}
在团队式开发中，通常在每次提交代码前执行 go clean 命令，防止提交编译时生成的文件。
:::

### go run

go run 命令的作用是直接运行 go 源码，不在当前目录下生成任何可执行的文件。


从原理上讲，go run 只是将编译后生成的可执行文件放到临时目录中执行，工作目录仍然为当前目录。同时，go run 命令允许添加参数，这些参数将作为 go 程序的可接受参数使用。

由此可见，go run 命令同样会执行编译操作。但要注意的是，go run 不适用于包的执行。


### go fmt

go fmt 命令的作用是将代码按照Go语言官方提供的代码风格进行格式化操作


![image.png](https://oss.silon.vip/img/738bb34adc98bed45fa33953d460448f.image.png)

```bash
go fmt
```


![image.png](https://oss.silon.vip/img/5976b88e37b61c2a7d351ec2374e7712.image.png)


### go vet

go vet 可以报告我们的包中可能存在的错误


![image.png](https://oss.silon.vip/img/c6d88e035c8a0e61c18b31841b0c95ba.image.png)

```bash
go vet
```


![image.png](https://oss.silon.vip/img/a9facf763e0126421568036fa69b59c2.image.png)

### go env

go env将简单地打印所有 go 环境信息

```bash
go env
```

![image.png](https://oss.silon.vip/img/d17e1f980dc0e04d2a426716ca5589be.image.png)

### go fix

go fix 可以找到使用旧 API 的 Go 程序，并使用新的 API重写它们


### go generate
go generate 通常用于代码生成。

它将扫描与当前包相关的源代码文件，找出所有包含 `//go:generate` 的特殊注释，提取并执行该特殊注释后面的命令。

### go doc

go doc 可以显示一个包或标识符的文档

```bash
go doc -src fmt Printf
```


![image.png](https://oss.silon.vip/img/c9f1dc407e6f1478636545b2d2a7adbb.image.png)

### go help

go help 可以查看所有 go 命令行可用的命令


![image.png](https://oss.silon.vip/img/5d0c988ddab83602329ab62026ea52fb.image.png)

Golang学习（16）：go 命令

## 工作区

工作区允许我们同时处理多个模块，而无需go.mod为每个模块编辑文件。


:::info{title="相关信息"}
解决依赖关系时，工作空间中的每个模块都被视为根模块，会优先使用。
:::





本篇中，创建一个新的文件夹 `workspace` 作为示例

```bash
# workspace
mkdir workspaces && cd workspaces

# 创建 modA 模块
mkdir modA && cd modA
go mod init modA

# 安装一个处理字符串的包
go get golang.org/x/example
```

```go
// 创建 modA/main.go

package main

import (
	"fmt"

	"golang.org/x/example/stringutil"
)

func main() {
	result := stringutil.Reverse("Hello Workspace")
	fmt.Println(result)
}
```

运行 `main.go`


![image.png](https://oss.silon.vip/img/d7736690622f707f59b0f4d851da3998.image.png)

## 创建工作区

```bash
// 在 workspace 目录下创建工作区
go work init
```

初始化工作区后，会创建一个 `go.work` 文件

![image.png](https://oss.silon.vip/img/438dfe9c8a2a8108af6022f17bc6a75d.image.png)


## 将模块引入工作区

```bash
// 将 modA 模块加入工作区
go work use ./modA
```

![image.png](https://oss.silon.vip/img/0dd41a63a1ea6cc52e6974139aebf8fb.image.png)

## 使用本地模块

```bash
// 将 example 模块下在本地
git clone https://go.googlesource.com/example
```

![image.png](https://oss.silon.vip/img/cc55f7a36d2b906d334a5a7009bb5d99.image.png)

```bash
// 将 example 模块添加至工作区
go work use ./example
```

**现在，由于已经有了本地工作区中的 example 模块，工作区中会优先使用该模块，而非下载的模块或包**

```go
// 修改本地模块中的 example/stringutil/reverse.go

package stringutil

func Reverse(s string) string {
    return "已经使用了工作区的模块"
}
```


![image.png](https://oss.silon.vip/img/7950244d5bc786fb1f74a285b0d5819c.image.png)


这时，再运行 main.go 可以发现已经使用了本地的模块中的功能


![image.png](https://oss.silon.vip/img/9e3cdd6317ebda8a72cfd847aade9ede.image.png)