## 工作区

工作区允许我们同时处理多个模块，而无需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)

Golang学习（15）：工作区

## 包声明

包：是包含一个或多个 Go 源文件或其他 Go 包的目录。
这意味着每个 Go 源文件都必须属于一个包，并且包声明在每个源文件的顶部完成

```go
// 该文件属于 main 包
package main
```




:::warning{title="注意"}
所以每个包的文件夹应各自独立
:::


- 虽然Go语法没有强制要求包名与其所在的目录名相同，但习惯上我们还是会保持这二者相同
- 包可以定义在多层级的目录中；
- 单个包的所有源码应存在相同的目录下，不同目录通常包含不同的包源码；
- 包名一般开头是小写的，采用小驼峰式命名法；
- 多个类似业务的公司可能会封装相同名称的包，为了确保唯一性，建议大家使用域名作为目录结构的一部分 。





:::info{title="相关信息"}
main包还应包含一个main()函数，该函数是一个特殊函数，充当可执行程序的入口点
:::

## 导入导出

### 导出

其他语言一样，go 也有导入和导出的概念

```go
// 创建一个 custom 文件夹作为 custom 包
// 在其中创建 code.go，声明包名
package custom


// 不会被导出
var value int = 10
// 会被导出
var Value int = 20
```


:::info{title="相关信息"}
首字母小写的标识符不会被导出，并且对于定义它的包来说是私有的
:::

### 导入

#### 外部的包

```go
// 下载一个日志记录包github.com/rs/zerolog/log

go install github.com/rs/zerolog
```

```go
package main

import (
    "github.com/rs/zerolog/log"

    cus "example/custom"
)

func main() {
    log.Print(cus.Value)
}
```


:::info{title="相关信息"}
- 安装的软件包的 go doc，它通常位于项目的自述文件中
- go doc 解析源代码并生成 HTML 格式的文档。对它的引用通常位于自述文件中。
:::

#### 导入自定义包

```go
// 导入单个包
import "modA/custom"
```

```go
// main.go

package main

// 导入多个包
import (
    "fmt"
    "modA/custom"
)

func main (){
    // 20
    fmt.Println(custom.Value)
    
    // undefined: custom.value
    fmt.Println(custom.value)
}
```


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


#### 设置包的别名

```go
package main

// 导入多个包
import (
    "fmt"
    cus "modA/custom"
)

func main (){
    // 使用别名
    fmt.Println(cus.Value)
}
```

Golang学习（14）：包

## 模块

Go语言是使用包来组织源代码的，包（package）是多个 Go 源码的集合，是一种高级的代码复用方案。Go语言中为我们提供了很多内置包，如 fmt、os、io 等。

模块，则是 go 包的集合。在模块的根目录，需要有一个`go.mod`文件来表明，这是一个模块。

> `包`由一个或多个源文件构成。这些源文件一起声明了属于该包的常量、类型、变量和函数，并且可以在同一包的所有文件中访问。同时这些元素可以导出，并在另一个包中使用（引用）。

Go 程序，就是通过调用各个模块中的包，在一个文件中，去完成一个更复杂的产品场景或功能。





### GOPATH

`GOPATH`是指工作区根目录的变量，可以通过`go env`进行查看，修改可以看【教程 02】，它包含以下文件夹：

- `src`：包含按层次结构组织的 Go 源代码（需要我们自己手动创建）。
- `pkg`：存储编译后生成的包文件 （自动生成）。
- `bin`：包含已编译的二进制文件和可执行文件(自动生成）。


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


### 创建模块


使用`go mod init` 可以命令创建一个新模块，该命令创建一个新模块并初始化go.mod描述它的文件

首先我们按照目录要求，在 `src` 中创建一个文件夹


```shell
// modA 为该模块的名称
go mod init modA
```


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

这时，会在当前目录下创建一个`go.mod` 文件，表示该目录是一个模块


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


### 配置模块

在 go.mod 中，可以对模块做个基本配置

```go
// 模块名
module modA


// go 语言版本
go 1.19

// 依赖的其他模块
require (
    ...
)
```

## 依赖管理

### 添加依赖

安装、编写一定要写在 GOPATH 下

我们可以使用 `go install` 添加一个依赖

go install 的编译过程有如下规律：
- go install 是建立在 GOPATH 上的，无法在独立的目录里使用 go install。
- GOPATH 下的 bin 目录放置的是使用 go install 生成的可执行文件，可执行文件的名称来自于编译时的包名。
- go install 输出目录始终为 GOPATH 下的 bin 目录，无法使用-o附加参数进行自定义。
- GOPATH 下的 pkg 目录放置的是编译期间的中间文件。

```shell
// 安装一个 github 上存储的包
go install github.com/rs/zerolog
```


:::info{title="相关信息"}
go install 只是将编译的中间文件放在 GOPATH 的 pkg 目录下，以及固定地将编译结果放在 GOPATH 的 bin 目录下
:::

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

这时会自动添加至 `go.mod` 的 `requeire` 中


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


同时生成一个 `go.sum` 的文件。此文件包含新模块内容的预期哈希值。


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

### 查看所有依赖

我们可以使用 `go list`列出当前模块所有依赖项

```shell
go list -m all
```

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


### 删除依赖项

我们可以使用`go mod tidy`命令简单地删除，模块中没有使用的包。同时整理直接引用和间接引用的包。

```go
// 模块根目录下创建 main.go 

package main

import "github.com/rs/zerolog/log"

func main() {
	log.Info().Msg("Hello")
}
```



```shell
// 该命令会删除所有依赖，相应修改 go.mod 和 go.sum 文件内容
go mod tidy
```

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

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


### 将依赖文件复制至项目内部

go 中可以使用`go mod vender`，将第三方包的文件复制到模块目录中，可以视为虚拟环境

```venv
go mod vender
```


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

Golang学习（13）：模块的创建与管理

## 函数的声明

```go
func function_name([params_list])([return_values_list]){
    // 函数体
}
```

- `func`关键字表示定义一个函数
- function_name是函数名
- params_list表示参数列表
- return_values_list表示函数的返回值列表
- 使用大括号包裹起来的部分称为函数体，是函数内部要执行的代码。





其中，参数列表和返回值列表是可选的。有些函数无需参数，有些参数运行后并不会有任何返回值，有些函数则无需参数也无需返回值


:::warning{title="注意"}
go 语言不允许函数的嵌套，因此函数应各自独立定义
:::


```go
func fn_a(a string) string{
    // do something
    return a
}

// 如果连续参数具有相同的类型，我们也可以进行速记声明
func fn_b(p1, p2 string) {}

// 没有参数和返回值的函数
func fn_c(){
    // do something
}

// 在别的函数调用一个函数
func main(){
    rst := fn_a("123")
    fmt.Println(rst)
}


// 123
```

## 返回值

```go
// go 中支持返回多个值
func fn_a()(string, int){
    return "123", 5
}

// go 还可以在函数体定义返回值的变量
// 不建议这么使用，会降低可读性
func fn_b()(s string, i int){
    var s string = "123"
    var i int = 5
    return 
}
```

:::warning{title="注意"}
1.  如果函数没有返回值，那么就是真的没有返回值，而不是默认返回一个值
:::
![image.png](https://oss.silon.vip/img/ba81c1599590c4e4d0d1a1acf24bc47d.image.png)


## 函数参数值的传递


:::warning{title="注意"}
直接传递一个变量名到另一个函数中，属于值传递
值传递不会修改原变量
:::
```go
func fn_a (num1 int, num2 int) {
    // 值传递
    num1 = num1 + num2
}

func main(){
    var a int = 5
    fn_a(a, 10)
    
    // 5
    fmt.Println(a)
}
```

如果想要修改原有的值，可以通过引用传递的方式实现（传递内存地址）
```go
func main(){
    var a int = 5
    // 传递了内存地址
    fn_a(&a, 10)
    
    // 15
    fmt.Println(a)
}

func fn_a (num1 *int, num2 int) {
    // 引用传递，这里直接修改了 a 内存中存储的值
    *num1 = *num1 + num2
}
```

还可以直接定义一个全局变量，这样可以直接操作修改

```go
// 所有函数都能修改这个全局变量，数据存在一定的安全风险。
A int = 5

main (){
    A += 10
}
```


## 作为值的函数（匿名函数）

go 中的函数可以直接作为一个值，类似 js 中的函数


```go
func myFunction() {
    // 这里实际是创建了一个匿名函数，赋给了 fn
    fn := func() {
	fmt.Println("inside fn")
    }

    // 调用
    fn()
}
```

匿名函数可以直接运行，所以上面的代码可以进行简化

```go
func myFunction() {
    // 这里实际是创建了一个匿名函数，直接调用，注意最后的括号
    func() {
	fmt.Println("inside fn")
    }()
}

```

## 闭包

闭包是指：
一个函数`fn_a`，是另一个函数`fn_b`的返回值

闭包意味着定义函数 `fn_a` 时访问 `fn_b` 范围内的值。

```go
func fn_b() func(int) int {
    sum := 0
    
    return func fn_a(v int) int {
        sum += v
        return sum
    }
}


add := fn_b()

add(5)


// 15
fmt.Println(add(10))
```



:::tip{title="解析"}
可以根据结果看到，sum 变量并不在 fn_a 的作用域内，但是被绑定到 fn_a 上了

好处是，这里的 sum 其实并不在外部作用域中，而是在 fn_b 中。
所以每次调用 add，都能拿到上次修改后的 sum 值
:::


:::info{title="使用闭包和使用普通函数的最大区别在于："}

如果是普通函数，那就是一次性买卖，函数执行完毕后就无法再更改函数中变量的值

- 使用闭包，函数就成为了一个变量的值。
  只要变量还在，函数就会一直处于存活并独享内部状态。方便后期更改函数中变量的值。
- 闭包还能起到一定的数据保护作用，比如这里的 sum 是不能再外部进行修改的
:::

利用闭包的特性，可以进行工厂模式相关的设计



## 可变参数

函数中，可以使用`...`省略号运算符接受零个或多个参数的函数

```go
func main() {
    sum := add(1,2,3,5)
    fmt.Println(sum)
}


// 注意这里的参数
func add(values ...int) int {
    sum := 0
    
    for _, v := range values {
        sum += v
    }
    
    return sum
}
```

## 初始化函数（init）

> init是在main函数之前执行的特殊生命周期函数。
> 与 类似main，该init函数不接受任何参数，也不返回任何值

```go
package main

import "fmt"

// 如果有多个 init 函数，则是按照定义顺序进行执行
func inti() {
    fmt.Println("初始化函数，先执行")
}

func main() {
    fmt.Println("main 函数，后执行")
}


/*
$ go run main.go
初始化函数，先执行
main 函数，后执行
*/
```


:::info{title="相关信息"}
init函数是可选的

适用于程序可能必不可少的任何全局设置，例如建立数据库连接、获取配置文件、设置环境变量等。
:::

## 延迟调用 （defer）


`defer` 关键字，它可以让我们推迟一个函数的执行，直到周围的函数返回

```go
func main() {
    defer fmt.Println("123")
    fmt.Println("234")
}
```

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


如果有多个 defer，则会进入一个 defer stack（堆，先入后出）
即，先声明的后执行

```go
func main() {
    defer fmt.Println("123")
    defer fmt.Println("234")

    fmt.Println("345")
    fmt.Println("456")
}
```


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


:::info{title="相关信息"}
defer 语句以后进先出的方式堆叠和执行。

因此，Defer 非常有用，通常用于进行清理或错误处理。


:::

Golang学习（12）：函数及应用

## 获取元素个数

Go语言内置了获取容器内元素个数的函数，这个函数对`数组`、`切片`和`集合`都有效，用法相同

```go
len(variable)
```

- len()表示调用函数，是固定写法
- variable为变量
- 调用后，函数将返回元素个数，返回值的类型是int




```go
var a []int

a = append(a, 1)
a = append(a, 3)
a = append(a, 5)
a = append(a, 7)

// 4
len(a)
```


## 修改元素

- 修改数组、切片和集合中的值，方法与赋值相同；
- 获取数组或切片的值，格式为variable[index]。
    - variable表示数组或切片的变量名
    - index表示索引值。
- 获取集合的值，格式为variable[key_value]。
    - variable表示集合的变量名
    - key_value表示键的值。
```go
var a[3]int
// 修改数组
a[0] = 5


var b[]int
b = append(b, 1)
b = append(b, 3)
// 修改切片
b[1] = 5


var c = make(map[int]string)
// 修改集合
c[1] = "5"
```

## 遍历

除了`for`循环外，Go语言还提供了`range`关键字。与for结合，也可以实现循环遍历。

**for-range结构同样适用于数组和切片**

其使用格式如下：

```go
for index, value := range variable {
    // 循环体
}
```
- index表示索引或键的值
- value表示元素的值
- variable表示数组、切片或集合变量
- 由大括号包裹的部分是循环体，可以使用index和value变量

```go
var c = make(map[int]string)
// 修改集合
c[1] = "5"
c[2] = "好"
c[3] = "a"

for key, value := range c {
    fmt.Print("键：", key, "值:", value)
}
```